token

Move path: 0x0000…0002::token
Functions: 4544 public, 0 entry
Structs: 6
Friend modules: None

token

Bytecode1003 lines

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

// Move bytecode v7

module 2.token {

use 0000000000000000000000000000000000000000000000000000000000000001::option;

use 0000000000000000000000000000000000000000000000000000000000000001::string;

use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

use 0000000000000000000000000000000000000000000000000000000000000002::balance;

use 0000000000000000000000000000000000000000000000000000000000000002::coin;

use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;

use 0000000000000000000000000000000000000000000000000000000000000002::event;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;

struct Token<phantom Ty0> has key {

id: UID,

balance: Balance<Ty0>

}

struct TokenPolicyCap<phantom Ty0> has store, key {

id: UID,

for: ID

}

struct TokenPolicy<phantom Ty0> has key {

id: UID,

spent_balance: Balance<Ty0>,

rules: VecMap<String, VecSet<TypeName>>

}

struct ActionRequest<phantom Ty0> {

name: String,

amount: u64,

sender: address,

recipient: Option<address>,

spent_balance: Option<Balance<Ty0>>,

approvals: VecSet<TypeName>

}

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

is_protected: bool

}

struct TokenPolicyCreated<phantom Ty0> has copy, drop {

id: ID,

is_mutable: bool

}

public new_policy<Ty0>(Arg0: &TreasuryCap<Ty0>, Arg1: &mut TxContext): TokenPolicy<Ty0> * TokenPolicyCap<Ty0> {

L2: loc0: TokenPolicyCap<Ty0>

L3: loc1: TokenPolicy<Ty0>

B0:

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

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

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

3Call vec_map::empty<String, VecSet<TypeName>>(): VecMap<String, VecSet<TypeName>>

4PackGeneric[0](TokenPolicy<Ty0>)

5StLoc[3](loc1: TokenPolicy<Ty0>)

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

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

8ImmBorrowLoc[3](loc1: TokenPolicy<Ty0>)

9Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID

10PackGeneric[1](TokenPolicyCap<Ty0>)

11StLoc[2](loc0: TokenPolicyCap<Ty0>)

12MoveLoc[3](loc1: TokenPolicy<Ty0>)

13MoveLoc[2](loc0: TokenPolicyCap<Ty0>)

14Ret

}

public share_policy<Ty0>(Arg0: TokenPolicy<Ty0>) {

B0:

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

1Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID

2LdTrue

3PackGeneric[2](TokenPolicyCreated<Ty0>)

4Call event::emit<TokenPolicyCreated<Ty0>>(TokenPolicyCreated<Ty0>)

5MoveLoc[0](Arg0: TokenPolicy<Ty0>)

6Call transfer::share_object<TokenPolicy<Ty0>>(TokenPolicy<Ty0>)

7Ret

}

public transfer<Ty0>(Arg0: Token<Ty0>, Arg1: address, Arg2: &mut TxContext): ActionRequest<Ty0> {

L3: loc0: u64

B0:

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

1ImmBorrowFieldGeneric[0](Token.balance: Balance<Ty0>)

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

3StLoc[3](loc0: u64)

4MoveLoc[0](Arg0: Token<Ty0>)

5CopyLoc[1](Arg1: address)

6Call transfer::transfer<Token<Ty0>>(Token<Ty0>, address)

7Call transfer_action(): String

8MoveLoc[3](loc0: u64)

9MoveLoc[1](Arg1: address)

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

11Call option::none<Balance<Ty0>>(): Option<Balance<Ty0>>

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

13FreezeRef

14Call new_request<Ty0>(String, u64, Option<address>, Option<Balance<Ty0>>, &TxContext): ActionRequest<Ty0>

15Ret

}

public spend<Ty0>(Arg0: Token<Ty0>, Arg1: &mut TxContext): ActionRequest<Ty0> {

L2: loc0: Balance<Ty0>

B0:

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

1UnpackGeneric[3](Token<Ty0>)

2StLoc[2](loc0: Balance<Ty0>)

3Call object::delete(UID)

4Call spend_action(): String

5ImmBorrowLoc[2](loc0: Balance<Ty0>)

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

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

8MoveLoc[2](loc0: Balance<Ty0>)

9Call option::some<Balance<Ty0>>(Balance<Ty0>): Option<Balance<Ty0>>

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

11FreezeRef

12Call new_request<Ty0>(String, u64, Option<address>, Option<Balance<Ty0>>, &TxContext): ActionRequest<Ty0>

13Ret

}

public to_coin<Ty0>(Arg0: Token<Ty0>, Arg1: &mut TxContext): Coin<Ty0> * ActionRequest<Ty0> {

L2: loc0: u64

L3: loc1: Balance<Ty0>

L4: loc2: UID

B0:

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

1UnpackGeneric[3](Token<Ty0>)

2StLoc[3](loc1: Balance<Ty0>)

3StLoc[4](loc2: UID)

4ImmBorrowLoc[3](loc1: Balance<Ty0>)

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

6StLoc[2](loc0: u64)

7MoveLoc[4](loc2: UID)

8Call object::delete(UID)

9MoveLoc[3](loc1: Balance<Ty0>)

10CopyLoc[1](Arg1: &mut TxContext)

11Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>

12Call to_coin_action(): String

13MoveLoc[2](loc0: u64)

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

15Call option::none<Balance<Ty0>>(): Option<Balance<Ty0>>

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

17FreezeRef

18Call new_request<Ty0>(String, u64, Option<address>, Option<Balance<Ty0>>, &TxContext): ActionRequest<Ty0>

19Ret

}

public from_coin<Ty0>(Arg0: Coin<Ty0>, Arg1: &mut TxContext): Token<Ty0> * ActionRequest<Ty0> {

L2: loc0: u64

B0:

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

1Call coin::value<Ty0>(&Coin<Ty0>): u64

2StLoc[2](loc0: u64)

3CopyLoc[1](Arg1: &mut TxContext)

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

5MoveLoc[0](Arg0: Coin<Ty0>)

6Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>

7PackGeneric[3](Token<Ty0>)

8Call from_coin_action(): String

9MoveLoc[2](loc0: u64)

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

11Call option::none<Balance<Ty0>>(): Option<Balance<Ty0>>

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

13FreezeRef

14Call new_request<Ty0>(String, u64, Option<address>, Option<Balance<Ty0>>, &TxContext): ActionRequest<Ty0>

15Ret

}

public join<Ty0>(Arg0: &mut Token<Ty0>, Arg1: Token<Ty0>) {

L2: loc0: Balance<Ty0>

L3: loc1: UID

B0:

0MoveLoc[1](Arg1: Token<Ty0>)

1UnpackGeneric[3](Token<Ty0>)

2StLoc[2](loc0: Balance<Ty0>)

3StLoc[3](loc1: UID)

4MoveLoc[0](Arg0: &mut Token<Ty0>)

5MutBorrowFieldGeneric[0](Token.balance: Balance<Ty0>)

6MoveLoc[2](loc0: Balance<Ty0>)

7Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64

8Pop

9MoveLoc[3](loc1: UID)

10Call object::delete(UID)

11Ret

}

public split<Ty0>(Arg0: &mut Token<Ty0>, Arg1: u64, Arg2: &mut TxContext): Token<Ty0> {

B0:

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

1ImmBorrowFieldGeneric[0](Token.balance: Balance<Ty0>)

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

3CopyLoc[1](Arg1: u64)

4Ge

5BrFalse(7)

B1:

6Branch(13)

B2:

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

8Pop

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

10Pop

11LdConst[3](u64: 3)

12Abort

B3:

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

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

15MoveLoc[0](Arg0: &mut Token<Ty0>)

16MutBorrowFieldGeneric[0](Token.balance: Balance<Ty0>)

17MoveLoc[1](Arg1: u64)

18Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>

19PackGeneric[3](Token<Ty0>)

20Ret

}

public zero<Ty0>(Arg0: &mut TxContext): Token<Ty0> {

B0:

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

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

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

3PackGeneric[3](Token<Ty0>)

4Ret

}

public destroy_zero<Ty0>(Arg0: Token<Ty0>) {

L1: loc0: Balance<Ty0>

L2: loc1: UID

B0:

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

1UnpackGeneric[3](Token<Ty0>)

2StLoc[1](loc0: Balance<Ty0>)

3StLoc[2](loc1: UID)

4ImmBorrowLoc[1](loc0: Balance<Ty0>)

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

6LdU64(0)

7Eq

8BrFalse(10)

B1:

9Branch(12)

B2:

10LdConst[4](u64: 4)

11Abort

B3:

12MoveLoc[1](loc0: Balance<Ty0>)

13Call balance::destroy_zero<Ty0>(Balance<Ty0>)

14MoveLoc[2](loc1: UID)

15Call object::delete(UID)

16Ret

}

public keep<Ty0>(Arg0: Token<Ty0>, Arg1: &mut TxContext) {

B0:

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

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

2FreezeRef

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

4Call transfer::transfer<Token<Ty0>>(Token<Ty0>, address)

5Ret

}

public new_request<Ty0>(Arg0: String, Arg1: u64, Arg2: Option<address>, Arg3: Option<Balance<Ty0>>, Arg4: &TxContext): ActionRequest<Ty0> {

L5: loc0: String

L6: loc1: u64

L7: loc2: Option<address>

L8: loc3: Option<Balance<Ty0>>

L9: loc4: address

L10: loc5: VecSet<TypeName>

B0:

0MoveLoc[0](Arg0: String)

1StLoc[5](loc0: String)

2MoveLoc[1](Arg1: u64)

3StLoc[6](loc1: u64)

4MoveLoc[2](Arg2: Option<address>)

5StLoc[7](loc2: Option<address>)

6MoveLoc[3](Arg3: Option<Balance<Ty0>>)

7StLoc[8](loc3: Option<Balance<Ty0>>)

8MoveLoc[4](Arg4: &TxContext)

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

10StLoc[9](loc4: address)

11Call vec_set::empty<TypeName>(): VecSet<TypeName>

12StLoc[10](loc5: VecSet<TypeName>)

13MoveLoc[5](loc0: String)

14MoveLoc[6](loc1: u64)

15MoveLoc[9](loc4: address)

16MoveLoc[7](loc2: Option<address>)

17MoveLoc[8](loc3: Option<Balance<Ty0>>)

18MoveLoc[10](loc5: VecSet<TypeName>)

19PackGeneric[4](ActionRequest<Ty0>)

20Ret

}

public confirm_request<Ty0>(Arg0: &TokenPolicy<Ty0>, Arg1: ActionRequest<Ty0>, Arg2: &mut TxContext): String * u64 * address * Option<address> {

L3: loc0: vector<TypeName>

L4: loc1: u64

L5: loc2: VecSet<TypeName>

L6: loc3: u64

L7: loc4: String

L8: loc5: Option<address>

L9: loc6: &TypeName

L10: loc7: &vector<TypeName>

L11: loc8: u64

L12: loc9: address

L13: loc10: Option<Balance<Ty0>>

B0:

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

1ImmBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)

2Call option::is_none<Balance<Ty0>>(&Option<Balance<Ty0>>): bool

3BrFalse(5)

B1:

4Branch(9)

B2:

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

6Pop

7LdConst[5](u64: 5)

8Abort

B3:

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

10ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)

11ImmBorrowLoc[1](Arg1: ActionRequest<Ty0>)

12ImmBorrowFieldGeneric[3](ActionRequest.name: String)

13Call vec_map::contains<String, VecSet<TypeName>>(&VecMap<String, VecSet<TypeName>>, &String): bool

14BrFalse(16)

B4:

15Branch(20)

B5:

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

17Pop

18LdConst[0](u64: 0)

19Abort

B6:

20MoveLoc[1](Arg1: ActionRequest<Ty0>)

21UnpackGeneric[4](ActionRequest<Ty0>)

22StLoc[5](loc2: VecSet<TypeName>)

23StLoc[13](loc10: Option<Balance<Ty0>>)

24StLoc[8](loc5: Option<address>)

25StLoc[12](loc9: address)

26StLoc[4](loc1: u64)

27StLoc[7](loc4: String)

28MoveLoc[13](loc10: Option<Balance<Ty0>>)

29Call option::destroy_none<Balance<Ty0>>(Option<Balance<Ty0>>)

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

31ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)

32ImmBorrowLoc[7](loc4: String)

33Call vec_map::get<String, VecSet<TypeName>>(&VecMap<String, VecSet<TypeName>>, &String): &VecSet<TypeName>

34ReadRef

35Call vec_set::into_keys<TypeName>(VecSet<TypeName>): vector<TypeName>

36StLoc[3](loc0: vector<TypeName>)

37ImmBorrowLoc[3](loc0: vector<TypeName>)

38StLoc[10](loc7: &vector<TypeName>)

39CopyLoc[10](loc7: &vector<TypeName>)

40VecLen(65)

41StLoc[11](loc8: u64)

42LdU64(0)

43StLoc[6](loc3: u64)

B7:

44CopyLoc[6](loc3: u64)

45CopyLoc[11](loc8: u64)

46Lt

47BrFalse(66)

B8:

48CopyLoc[10](loc7: &vector<TypeName>)

49CopyLoc[6](loc3: u64)

50VecImmBorrow(65)

51StLoc[9](loc6: &TypeName)

52ImmBorrowLoc[5](loc2: VecSet<TypeName>)

53MoveLoc[9](loc6: &TypeName)

54Call vec_set::contains<TypeName>(&VecSet<TypeName>, &TypeName): bool

55BrFalse(57)

B9:

56Branch(61)

B10:

57MoveLoc[10](loc7: &vector<TypeName>)

58Pop

59LdConst[1](u64: 1)

60Abort

B11:

61MoveLoc[6](loc3: u64)

62LdU64(1)

63Add

64StLoc[6](loc3: u64)

65Branch(44)

B12:

66MoveLoc[10](loc7: &vector<TypeName>)

67Pop

68MoveLoc[7](loc4: String)

69MoveLoc[4](loc1: u64)

70MoveLoc[12](loc9: address)

71MoveLoc[8](loc5: Option<address>)

72Ret

}

public confirm_request_mut<Ty0>(Arg0: &mut TokenPolicy<Ty0>, Arg1: ActionRequest<Ty0>, Arg2: &mut TxContext): String * u64 * address * Option<address> {

B0:

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

1ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)

2ImmBorrowLoc[1](Arg1: ActionRequest<Ty0>)

3ImmBorrowFieldGeneric[3](ActionRequest.name: String)

4Call vec_map::contains<String, VecSet<TypeName>>(&VecMap<String, VecSet<TypeName>>, &String): bool

5BrFalse(7)

B1:

6Branch(13)

B2:

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

8Pop

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

10Pop

11LdConst[0](u64: 0)

12Abort

B3:

13ImmBorrowLoc[1](Arg1: ActionRequest<Ty0>)

14ImmBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)

15Call option::is_some<Balance<Ty0>>(&Option<Balance<Ty0>>): bool

16BrFalse(18)

B4:

17Branch(24)

B5:

18MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)

19Pop

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

21Pop

22LdConst[7](u64: 7)

23Abort

B6:

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

25MutBorrowFieldGeneric[4](TokenPolicy.spent_balance: Balance<Ty0>)

26MutBorrowLoc[1](Arg1: ActionRequest<Ty0>)

27MutBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)

28Call option::extract<Balance<Ty0>>(&mut Option<Balance<Ty0>>): Balance<Ty0>

29Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64

30Pop

31MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)

32FreezeRef

33MoveLoc[1](Arg1: ActionRequest<Ty0>)

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

35Call confirm_request<Ty0>(&TokenPolicy<Ty0>, ActionRequest<Ty0>, &mut TxContext): String * u64 * address * Option<address>

36Ret

}

public confirm_with_policy_cap<Ty0>(Arg0: &TokenPolicyCap<Ty0>, Arg1: ActionRequest<Ty0>, Arg2: &mut TxContext): String * u64 * address * Option<address> {

L3: loc0: u64

L4: loc1: String

L5: loc2: Option<address>

L6: loc3: address

L7: loc4: Option<Balance<Ty0>>

B0:

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

1ImmBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)

2Call option::is_none<Balance<Ty0>>(&Option<Balance<Ty0>>): bool

3BrFalse(5)

B1:

4Branch(7)

B2:

5LdConst[5](u64: 5)

6Abort

B3:

7MoveLoc[1](Arg1: ActionRequest<Ty0>)

8UnpackGeneric[4](ActionRequest<Ty0>)

9Pop

10StLoc[7](loc4: Option<Balance<Ty0>>)

11StLoc[5](loc2: Option<address>)

12StLoc[6](loc3: address)

13StLoc[3](loc0: u64)

14StLoc[4](loc1: String)

15MoveLoc[7](loc4: Option<Balance<Ty0>>)

16Call option::destroy_none<Balance<Ty0>>(Option<Balance<Ty0>>)

17MoveLoc[4](loc1: String)

18MoveLoc[3](loc0: u64)

19MoveLoc[6](loc3: address)

20MoveLoc[5](loc2: Option<address>)

21Ret

}

public confirm_with_treasury_cap<Ty0>(Arg0: &mut TreasuryCap<Ty0>, Arg1: ActionRequest<Ty0>, Arg2: &mut TxContext): String * u64 * address * Option<address> {

L3: loc0: u64

L4: loc1: String

L5: loc2: Option<address>

L6: loc3: address

L7: loc4: Option<Balance<Ty0>>

B0:

0MoveLoc[1](Arg1: ActionRequest<Ty0>)

1UnpackGeneric[4](ActionRequest<Ty0>)

2Pop

3StLoc[7](loc4: Option<Balance<Ty0>>)

4StLoc[5](loc2: Option<address>)

5StLoc[6](loc3: address)

6StLoc[3](loc0: u64)

7StLoc[4](loc1: String)

8ImmBorrowLoc[7](loc4: Option<Balance<Ty0>>)

9Call option::is_some<Balance<Ty0>>(&Option<Balance<Ty0>>): bool

10BrFalse(18)

B1:

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

12Call coin::supply_mut<Ty0>(&mut TreasuryCap<Ty0>): &mut Supply<Ty0>

13MoveLoc[7](loc4: Option<Balance<Ty0>>)

14Call option::destroy_some<Balance<Ty0>>(Option<Balance<Ty0>>): Balance<Ty0>

15Call balance::decrease_supply<Ty0>(&mut Supply<Ty0>, Balance<Ty0>): u64

16Pop

17Branch(22)

B2:

18MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)

19Pop

20MoveLoc[7](loc4: Option<Balance<Ty0>>)

21Call option::destroy_none<Balance<Ty0>>(Option<Balance<Ty0>>)

B3:

22MoveLoc[4](loc1: String)

23MoveLoc[3](loc0: u64)

24MoveLoc[6](loc3: address)

25MoveLoc[5](loc2: Option<address>)

26Ret

}

public add_approval<Ty0, Ty1: drop>(Arg0: Ty1, Arg1: &mut ActionRequest<Ty0>, Arg2: &mut TxContext) {

B0:

0MoveLoc[1](Arg1: &mut ActionRequest<Ty0>)

1MutBorrowFieldGeneric[5](ActionRequest.approvals: VecSet<TypeName>)

2Call type_name::with_defining_ids<Ty1>(): TypeName

3Call vec_set::insert<TypeName>(&mut VecSet<TypeName>, TypeName)

4Ret

}

public add_rule_config<Ty0, Ty1: drop, Ty2: store>(Arg0: Ty1, Arg1: &mut TokenPolicy<Ty0>, Arg2: &TokenPolicyCap<Ty0>, Arg3: Ty2, Arg4: &mut TxContext) {

B0:

0CopyLoc[1](Arg1: &mut TokenPolicy<Ty0>)

1FreezeRef

2Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID

3MoveLoc[2](Arg2: &TokenPolicyCap<Ty0>)

4ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)

5ReadRef

6Eq

7BrFalse(9)

B1:

8Branch(13)

B2:

9MoveLoc[1](Arg1: &mut TokenPolicy<Ty0>)

10Pop

11LdConst[2](u64: 2)

12Abort

B3:

13MoveLoc[1](Arg1: &mut TokenPolicy<Ty0>)

14MutBorrowFieldGeneric[7](TokenPolicy.id: UID)

15Call key<Ty1>(): RuleKey<Ty1>

16MoveLoc[3](Arg3: Ty2)

17Call dynamic_field::add<RuleKey<Ty1>, Ty2>(&mut UID, RuleKey<Ty1>, Ty2)

18Ret

}

public rule_config<Ty0, Ty1: drop, Ty2: store>(Arg0: Ty1, Arg1: &TokenPolicy<Ty0>): &Ty2 {

B0:

0CopyLoc[1](Arg1: &TokenPolicy<Ty0>)

1Call has_rule_config_with_type<Ty0, Ty1, Ty2>(&TokenPolicy<Ty0>): bool

2BrFalse(4)

B1:

3Branch(8)

B2:

4MoveLoc[1](Arg1: &TokenPolicy<Ty0>)

5Pop

6LdConst[6](u64: 6)

7Abort

B3:

8MoveLoc[1](Arg1: &TokenPolicy<Ty0>)

9ImmBorrowFieldGeneric[7](TokenPolicy.id: UID)

10Call key<Ty1>(): RuleKey<Ty1>

11Call dynamic_field::borrow<RuleKey<Ty1>, Ty2>(&UID, RuleKey<Ty1>): &Ty2

12Ret

}

public rule_config_mut<Ty0, Ty1: drop, Ty2: store>(Arg0: Ty1, Arg1: &mut TokenPolicy<Ty0>, Arg2: &TokenPolicyCap<Ty0>): &mut Ty2 {

B0:

0CopyLoc[1](Arg1: &mut TokenPolicy<Ty0>)

1FreezeRef

2Call has_rule_config_with_type<Ty0, Ty1, Ty2>(&TokenPolicy<Ty0>): bool

3BrFalse(5)

B1:

4Branch(11)

B2:

5MoveLoc[1](Arg1: &mut TokenPolicy<Ty0>)

6Pop

7MoveLoc[2](Arg2: &TokenPolicyCap<Ty0>)

8Pop

9LdConst[6](u64: 6)

10Abort

B3:

11CopyLoc[1](Arg1: &mut TokenPolicy<Ty0>)

12FreezeRef

13Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID

14MoveLoc[2](Arg2: &TokenPolicyCap<Ty0>)

15ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)

16ReadRef

17Eq

18BrFalse(20)

B4:

19Branch(24)

B5:

20MoveLoc[1](Arg1: &mut TokenPolicy<Ty0>)

21Pop

22LdConst[2](u64: 2)

23Abort

B6:

24MoveLoc[1](Arg1: &mut TokenPolicy<Ty0>)

25MutBorrowFieldGeneric[7](TokenPolicy.id: UID)

26Call key<Ty1>(): RuleKey<Ty1>

27Call dynamic_field::borrow_mut<RuleKey<Ty1>, Ty2>(&mut UID, RuleKey<Ty1>): &mut Ty2

28Ret

}

public remove_rule_config<Ty0, Ty1, Ty2: store>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &TokenPolicyCap<Ty0>, Arg2: &mut TxContext): Ty2 {

B0:

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

1FreezeRef

2Call has_rule_config_with_type<Ty0, Ty1, Ty2>(&TokenPolicy<Ty0>): bool

3BrFalse(5)

B1:

4Branch(11)

B2:

5MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)

6Pop

7MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)

8Pop

9LdConst[6](u64: 6)

10Abort

B3:

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

12FreezeRef

13Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID

14MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)

15ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)

16ReadRef

17Eq

18BrFalse(20)

B4:

19Branch(24)

B5:

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

21Pop

22LdConst[2](u64: 2)

23Abort

B6:

24MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)

25MutBorrowFieldGeneric[7](TokenPolicy.id: UID)

26Call key<Ty1>(): RuleKey<Ty1>

27Call dynamic_field::remove<RuleKey<Ty1>, Ty2>(&mut UID, RuleKey<Ty1>): Ty2

28Ret

}

public has_rule_config<Ty0, Ty1>(Arg0: &TokenPolicy<Ty0>): bool {

B0:

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

1ImmBorrowFieldGeneric[7](TokenPolicy.id: UID)

2Call key<Ty1>(): RuleKey<Ty1>

3Call dynamic_field::exists<RuleKey<Ty1>>(&UID, RuleKey<Ty1>): bool

4Ret

}

public has_rule_config_with_type<Ty0, Ty1, Ty2: store>(Arg0: &TokenPolicy<Ty0>): bool {

B0:

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

1ImmBorrowFieldGeneric[7](TokenPolicy.id: UID)

2Call key<Ty1>(): RuleKey<Ty1>

3Call dynamic_field::exists_with_type<RuleKey<Ty1>, Ty2>(&UID, RuleKey<Ty1>): bool

4Ret

}

public allow<Ty0>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &TokenPolicyCap<Ty0>, Arg2: String, Arg3: &mut TxContext) {

B0:

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

1FreezeRef

2Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID

3MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)

4ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)

5ReadRef

6Eq

7BrFalse(9)

B1:

8Branch(13)

B2:

9MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)

10Pop

11LdConst[2](u64: 2)

12Abort

B3:

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

14MutBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)

15MoveLoc[2](Arg2: String)

16Call vec_set::empty<TypeName>(): VecSet<TypeName>

17Call vec_map::insert<String, VecSet<TypeName>>(&mut VecMap<String, VecSet<TypeName>>, String, VecSet<TypeName>)

18Ret

}

public disallow<Ty0>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &TokenPolicyCap<Ty0>, Arg2: String, Arg3: &mut TxContext) {

B0:

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

1FreezeRef

2Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID

3MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)

4ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)

5ReadRef

6Eq

7BrFalse(9)

B1:

8Branch(13)

B2:

9MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)

10Pop

11LdConst[2](u64: 2)

12Abort

B3:

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

14MutBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)

15ImmBorrowLoc[2](Arg2: String)

16Call vec_map::remove<String, VecSet<TypeName>>(&mut VecMap<String, VecSet<TypeName>>, &String): String * VecSet<TypeName>

17Pop

18Pop

19Ret

}

public add_rule_for_action<Ty0, Ty1: drop>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &TokenPolicyCap<Ty0>, Arg2: String, Arg3: &mut TxContext) {

B0:

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

1FreezeRef

2Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID

3CopyLoc[1](Arg1: &TokenPolicyCap<Ty0>)

4ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)

5ReadRef

6Eq

7BrFalse(9)

B1:

8Branch(17)

B2:

9MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)

10Pop

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

12Pop

13MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)

14Pop

15LdConst[2](u64: 2)

16Abort

B3:

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

18ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)

19ImmBorrowLoc[2](Arg2: String)

20Call vec_map::contains<String, VecSet<TypeName>>(&VecMap<String, VecSet<TypeName>>, &String): bool

21Not

22BrFalse(29)

B4:

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

24MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)

25CopyLoc[2](Arg2: String)

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

27Call allow<Ty0>(&mut TokenPolicy<Ty0>, &TokenPolicyCap<Ty0>, String, &mut TxContext)

28Branch(33)

B5:

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

30Pop

31MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)

32Pop

B6:

33MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)

34MutBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)

35ImmBorrowLoc[2](Arg2: String)

36Call vec_map::get_mut<String, VecSet<TypeName>>(&mut VecMap<String, VecSet<TypeName>>, &String): &mut VecSet<TypeName>

37Call type_name::with_defining_ids<Ty1>(): TypeName

38Call vec_set::insert<TypeName>(&mut VecSet<TypeName>, TypeName)

39Ret

}

public remove_rule_for_action<Ty0, Ty1: drop>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &TokenPolicyCap<Ty0>, Arg2: String, Arg3: &mut TxContext) {

L4: loc0: TypeName

L5: loc1: &mut VecSet<TypeName>

B0:

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

1FreezeRef

2Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID

3MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)

4ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)

5ReadRef

6Eq

7BrFalse(9)

B1:

8Branch(13)

B2:

9MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)

10Pop

11LdConst[2](u64: 2)

12Abort

B3:

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

14MutBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)

15ImmBorrowLoc[2](Arg2: String)

16Call vec_map::get_mut<String, VecSet<TypeName>>(&mut VecMap<String, VecSet<TypeName>>, &String): &mut VecSet<TypeName>

17StLoc[5](loc1: &mut VecSet<TypeName>)

18Call type_name::with_defining_ids<Ty1>(): TypeName

19StLoc[4](loc0: TypeName)

20MoveLoc[5](loc1: &mut VecSet<TypeName>)

21ImmBorrowLoc[4](loc0: TypeName)

22Call vec_set::remove<TypeName>(&mut VecSet<TypeName>, &TypeName)

23Ret

}

public mint<Ty0>(Arg0: &mut TreasuryCap<Ty0>, Arg1: u64, Arg2: &mut TxContext): Token<Ty0> {

L3: loc0: Balance<Ty0>

B0:

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

1Call coin::supply_mut<Ty0>(&mut TreasuryCap<Ty0>): &mut Supply<Ty0>

2MoveLoc[1](Arg1: u64)

3Call balance::increase_supply<Ty0>(&mut Supply<Ty0>, u64): Balance<Ty0>

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

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

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

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

8PackGeneric[3](Token<Ty0>)

9Ret

}

public burn<Ty0>(Arg0: &mut TreasuryCap<Ty0>, Arg1: Token<Ty0>) {

L2: loc0: Balance<Ty0>

L3: loc1: UID

B0:

0MoveLoc[1](Arg1: Token<Ty0>)

1UnpackGeneric[3](Token<Ty0>)

2StLoc[2](loc0: Balance<Ty0>)

3StLoc[3](loc1: UID)

4MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)

5Call coin::supply_mut<Ty0>(&mut TreasuryCap<Ty0>): &mut Supply<Ty0>

6MoveLoc[2](loc0: Balance<Ty0>)

7Call balance::decrease_supply<Ty0>(&mut Supply<Ty0>, Balance<Ty0>): u64

8Pop

9MoveLoc[3](loc1: UID)

10Call object::delete(UID)

11Ret

}

public flush<Ty0>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &mut TreasuryCap<Ty0>, Arg2: &mut TxContext): u64 {

L3: loc0: u64

L4: loc1: Balance<Ty0>

B0:

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

1ImmBorrowFieldGeneric[4](TokenPolicy.spent_balance: Balance<Ty0>)

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

3StLoc[3](loc0: u64)

4MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)

5MutBorrowFieldGeneric[4](TokenPolicy.spent_balance: Balance<Ty0>)

6MoveLoc[3](loc0: u64)

7Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>

8StLoc[4](loc1: Balance<Ty0>)

9MoveLoc[1](Arg1: &mut TreasuryCap<Ty0>)

10Call coin::supply_mut<Ty0>(&mut TreasuryCap<Ty0>): &mut Supply<Ty0>

11MoveLoc[4](loc1: Balance<Ty0>)

12Call balance::decrease_supply<Ty0>(&mut Supply<Ty0>, Balance<Ty0>): u64

13Ret

}

public is_allowed<Ty0>(Arg0: &TokenPolicy<Ty0>, Arg1: &String): bool {

B0:

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

1ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)

2MoveLoc[1](Arg1: &String)

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

4Ret

}

public rules<Ty0>(Arg0: &TokenPolicy<Ty0>, Arg1: &String): VecSet<TypeName> {

B0:

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

1ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)

2MoveLoc[1](Arg1: &String)

3Call vec_map::get<String, VecSet<TypeName>>(&VecMap<String, VecSet<TypeName>>, &String): &VecSet<TypeName>

4ReadRef

5Ret

}

public spent_balance<Ty0>(Arg0: &TokenPolicy<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[4](TokenPolicy.spent_balance: Balance<Ty0>)

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

3Ret

}

public value<Ty0>(Arg0: &Token<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[0](Token.balance: Balance<Ty0>)

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

3Ret

}

public transfer_action(): String {

B0:

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

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

2Ret

}

public spend_action(): String {

B0:

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

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

2Ret

}

public to_coin_action(): String {

B0:

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

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

2Ret

}

public from_coin_action(): String {

B0:

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

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

2Ret

}

public action<Ty0>(Arg0: &ActionRequest<Ty0>): String {

B0:

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

1ImmBorrowFieldGeneric[3](ActionRequest.name: String)

2ReadRef

3Ret

}

public amount<Ty0>(Arg0: &ActionRequest<Ty0>): u64 {

B0:

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

1ImmBorrowFieldGeneric[8](ActionRequest.amount: u64)

2ReadRef

3Ret

}

public sender<Ty0>(Arg0: &ActionRequest<Ty0>): address {

B0:

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

1ImmBorrowFieldGeneric[9](ActionRequest.sender: address)

2ReadRef

3Ret

}

public recipient<Ty0>(Arg0: &ActionRequest<Ty0>): Option<address> {

B0:

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

1ImmBorrowFieldGeneric[10](ActionRequest.recipient: Option<address>)

2ReadRef

3Ret

}

public approvals<Ty0>(Arg0: &ActionRequest<Ty0>): VecSet<TypeName> {

B0:

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

1ImmBorrowFieldGeneric[5](ActionRequest.approvals: VecSet<TypeName>)

2ReadRef

3Ret

}

public spent<Ty0>(Arg0: &ActionRequest<Ty0>): Option<u64> {

L1: loc0: Option<u64>

B0:

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

1ImmBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)

2Call option::is_some<Balance<Ty0>>(&Option<Balance<Ty0>>): bool

3BrFalse(11)

B1:

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

5ImmBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)

6Call option::borrow<Balance<Ty0>>(&Option<Balance<Ty0>>): &Balance<Ty0>

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

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

9StLoc[1](loc0: Option<u64>)

10Branch(15)

B2:

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

12Pop

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

14StLoc[1](loc0: Option<u64>)

B3:

15MoveLoc[1](loc0: Option<u64>)

16Ret

}

key<Ty0>(): RuleKey<Ty0> {

B0:

0LdTrue

1PackGeneric[5](RuleKey<Ty0>)

2Ret

}

Constants [

0 => u64: 0

1 => u64: 1

2 => u64: 2

3 => u64: 3

4 => u64: 4

5 => u64: 5

6 => u64: 6

7 => u64: 7

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

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

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

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

]

}