address_alias

Module0x0000…0002

Move path: 0x0000…0002::address_alias
Functions: 50 public, 4 entry
Structs: 3
Friend modules: None

address_alias

Bytecode207 lines

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

// Move bytecode v7

module 2.address_alias {

use 0000000000000000000000000000000000000000000000000000000000000002::derived_object;

use 0000000000000000000000000000000000000000000000000000000000000002::object;

use 0000000000000000000000000000000000000000000000000000000000000002::party;

use 0000000000000000000000000000000000000000000000000000000000000002::transfer;

use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;

struct AddressAliasState has key {

id: UID,

version: u64

}

struct AddressAliases has key {

id: UID,

aliases: VecSet<address>

}

struct AliasKey has copy, drop, store {

pos0: address

}

create(Arg0: &TxContext) {

B0:

0MoveLoc[0](Arg0: &TxContext)

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

2LdConst[12](address: 0x00..)

3Eq

4BrFalse(6)

B1:

5Branch(8)

B2:

6LdU64(13835058231375822849)

7Abort

B3:

8Call object::address_alias_state(): UID

9LdConst[10](u64: 0)

10Pack[0](AddressAliasState)

11Call transfer::share_object<AddressAliasState>(AddressAliasState)

12Ret

}

entry enable(Arg0: &mut AddressAliasState, Arg1: &TxContext) {

B0:

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

1ImmBorrowField[0](AddressAliasState.id: UID)

2CopyLoc[1](Arg1: &TxContext)

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

4Pack[2](AliasKey)

5Call derived_object::exists<AliasKey>(&UID, AliasKey): bool

6Not

7BrFalse(9)

B1:

8Branch(15)

B2:

9MoveLoc[1](Arg1: &TxContext)

10Pop

11MoveLoc[0](Arg0: &mut AddressAliasState)

12Pop

13LdU64(13835621305883557893)

14Abort

B3:

15MoveLoc[0](Arg0: &mut AddressAliasState)

16MutBorrowField[0](AddressAliasState.id: UID)

17CopyLoc[1](Arg1: &TxContext)

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

19Pack[2](AliasKey)

20Call derived_object::claim<AliasKey>(&mut UID, AliasKey): UID

21CopyLoc[1](Arg1: &TxContext)

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

23Call vec_set::singleton<address>(address): VecSet<address>

24Pack[1](AddressAliases)

25MoveLoc[1](Arg1: &TxContext)

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

27Call party::single_owner(address): Party

28Call transfer::party_transfer<AddressAliases>(AddressAliases, Party)

29Ret

}

entry add(Arg0: &mut AddressAliases, Arg1: address) {

B0:

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

1ImmBorrowField[1](AddressAliases.aliases: VecSet<address>)

2ImmBorrowLoc[1](Arg1: address)

3Call vec_set::contains<address>(&VecSet<address>, &address): bool

4Not

5BrFalse(7)

B1:

6Branch(11)

B2:

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

8Pop

9LdU64(13835621361718132741)

10Abort

B3:

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

12MutBorrowField[1](AddressAliases.aliases: VecSet<address>)

13MoveLoc[1](Arg1: address)

14Call vec_set::insert<address>(&mut VecSet<address>, address)

15MoveLoc[0](Arg0: &mut AddressAliases)

16ImmBorrowField[1](AddressAliases.aliases: VecSet<address>)

17Call vec_set::length<address>(&VecSet<address>): u64

18LdConst[11](u64: 8)

19Le

20BrFalse(22)

B4:

21Branch(24)

B5:

22LdU64(13836184320261750793)

23Abort

B6:

24Ret

}

entry replace_all(Arg0: &mut AddressAliases, Arg1: vector<address>) {

L2: loc0: VecSet<address>

B0:

0MoveLoc[1](Arg1: vector<address>)

1Call vec_set::from_keys<address>(vector<address>): VecSet<address>

2StLoc[2](loc0: VecSet<address>)

3ImmBorrowLoc[2](loc0: VecSet<address>)

4Call vec_set::length<address>(&VecSet<address>): u64

5LdU64(0)

6Gt

7BrFalse(9)

B1:

8Branch(13)

B2:

9MoveLoc[0](Arg0: &mut AddressAliases)

10Pop

11LdU64(13835902871054712839)

12Abort

B3:

13ImmBorrowLoc[2](loc0: VecSet<address>)

14Call vec_set::length<address>(&VecSet<address>): u64

15LdConst[11](u64: 8)

16Le

17BrFalse(19)

B4:

18Branch(23)

B5:

19MoveLoc[0](Arg0: &mut AddressAliases)

20Pop

21LdU64(13836184350326521865)

22Abort

B6:

23MoveLoc[2](loc0: VecSet<address>)

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

25MutBorrowField[1](AddressAliases.aliases: VecSet<address>)

26WriteRef

27Ret

}

entry remove(Arg0: &mut AddressAliases, Arg1: address) {

B0:

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

1ImmBorrowField[1](AddressAliases.aliases: VecSet<address>)

2ImmBorrowLoc[1](Arg1: address)

3Call vec_set::contains<address>(&VecSet<address>, &address): bool

4BrFalse(6)

B1:

5Branch(10)

B2:

6MoveLoc[0](Arg0: &mut AddressAliases)

7Pop

8LdU64(13835339951165800451)

9Abort

B3:

10CopyLoc[0](Arg0: &mut AddressAliases)

11ImmBorrowField[1](AddressAliases.aliases: VecSet<address>)

12Call vec_set::length<address>(&VecSet<address>): u64

13LdU64(1)

14Gt

15BrFalse(17)

B4:

16Branch(21)

B5:

17MoveLoc[0](Arg0: &mut AddressAliases)

18Pop

19LdU64(13835902905414451207)

20Abort

B6:

21MoveLoc[0](Arg0: &mut AddressAliases)

22MutBorrowField[1](AddressAliases.aliases: VecSet<address>)

23ImmBorrowLoc[1](Arg1: address)

24Call vec_set::remove<address>(&mut VecSet<address>, &address)

25Ret

}

Constants [

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

1 => vector<u8>: "Only the system can create the alias state object." // interpreted as UTF8 string

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

3 => vector<u8>: "Given alias does not exist." // interpreted as UTF8 string

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

5 => vector<u8>: "Alias already exists." // interpreted as UTF8 string

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

7 => vector<u8>: "Cannot remove the last alias." // interpreted as UTF8 string

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

9 => vector<u8>: "The number of aliases exceeds the maximum allowed." // interpreted as UTF8 string

10 => u64: 0

11 => u64: 8

12 => address: 0x0000000000000000000000000000000000000000000000000000000000000000

]

}