vault
Module0x79fa…3a87
- Move path
- 0x79fa…3a87::vault
- Functions
- 87 public, 6 entry
- Structs
- 2
- Friend modules
- None
vault
Bytecode248 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v6
module 79fa20e2a4cebf9ca7cdc044dc3fb284b092183c5834a835ce416969f8df3a87.vault {
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct AdminCap has key {
id: UID
}
struct Vault has key {
id: UID,
members: VecSet<address>
}
init(Arg0: &mut TxContext) {
L1: loc0: Vault
B0:
0CopyLoc[0](Arg0: &mut TxContext)
1Call object::new(&mut TxContext): UID
2Pack[0](AdminCap)
3CopyLoc[0](Arg0: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6Call transfer::transfer<AdminCap>(AdminCap, address)
7CopyLoc[0](Arg0: &mut TxContext)
8Call object::new(&mut TxContext): UID
9Call vec_set::empty<address>(): VecSet<address>
10Pack[1](Vault)
11StLoc[1](loc0: Vault)
12MutBorrowLoc[1](loc0: Vault)
13MutBorrowField[0](Vault.members: VecSet<address>)
14MoveLoc[0](Arg0: &mut TxContext)
15FreezeRef
16Call tx_context::sender(&TxContext): address
17Call vec_set::insert<address>(&mut VecSet<address>, address)
18MoveLoc[1](loc0: Vault)
19Call transfer::share_object<Vault>(Vault)
20Ret
}
entry public transfer_admin(Arg0: AdminCap, Arg1: &mut Vault, Arg2: address, Arg3: &TxContext) {
L4: loc0: address
L5: loc1: &VecSet<address>
L6: loc2: address
L7: loc3: &mut VecSet<address>
B0:
0CopyLoc[1](Arg1: &mut Vault)
1ImmBorrowField[0](Vault.members: VecSet<address>)
2StLoc[5](loc1: &VecSet<address>)
3CopyLoc[3](Arg3: &TxContext)
4Call tx_context::sender(&TxContext): address
5StLoc[4](loc0: address)
6MoveLoc[5](loc1: &VecSet<address>)
7ImmBorrowLoc[4](loc0: address)
8Call vec_set::contains<address>(&VecSet<address>, &address): bool
9BrFalse(20)
B1:
10CopyLoc[1](Arg1: &mut Vault)
11MutBorrowField[0](Vault.members: VecSet<address>)
12StLoc[7](loc3: &mut VecSet<address>)
13MoveLoc[3](Arg3: &TxContext)
14Call tx_context::sender(&TxContext): address
15StLoc[6](loc2: address)
16MoveLoc[7](loc3: &mut VecSet<address>)
17ImmBorrowLoc[6](loc2: address)
18Call vec_set::remove<address>(&mut VecSet<address>, &address)
19Branch(22)
B2:
20MoveLoc[3](Arg3: &TxContext)
21Pop
B3:
22CopyLoc[1](Arg1: &mut Vault)
23ImmBorrowField[0](Vault.members: VecSet<address>)
24ImmBorrowLoc[2](Arg2: address)
25Call vec_set::contains<address>(&VecSet<address>, &address): bool
26Not
27BrFalse(33)
B4:
28MoveLoc[1](Arg1: &mut Vault)
29MutBorrowField[0](Vault.members: VecSet<address>)
30CopyLoc[2](Arg2: address)
31Call vec_set::insert<address>(&mut VecSet<address>, address)
32Branch(35)
B5:
33MoveLoc[1](Arg1: &mut Vault)
34Pop
B6:
35MoveLoc[0](Arg0: AdminCap)
36MoveLoc[2](Arg2: address)
37Call transfer::transfer<AdminCap>(AdminCap, address)
38Ret
}
entry public add_member(Arg0: &AdminCap, Arg1: &mut Vault, Arg2: address) {
B0:
0MoveLoc[1](Arg1: &mut Vault)
1MutBorrowField[0](Vault.members: VecSet<address>)
2MoveLoc[2](Arg2: address)
3Call vec_set::insert<address>(&mut VecSet<address>, address)
4Ret
}
entry public revoke_membership(Arg0: &AdminCap, Arg1: &mut Vault, Arg2: address) {
B0:
0MoveLoc[1](Arg1: &mut Vault)
1MutBorrowField[0](Vault.members: VecSet<address>)
2ImmBorrowLoc[2](Arg2: address)
3Call vec_set::remove<address>(&mut VecSet<address>, &address)
4Ret
}
entry public deposit<Ty0>(Arg0: &mut Vault, Arg1: Coin<Ty0>) {
L2: loc0: Balance<Ty0>
L3: loc1: TypeName
L4: loc2: Balance<Ty0>
B0:
0Call type_name::get<Ty0>(): TypeName
1StLoc[3](loc1: TypeName)
2MoveLoc[1](Arg1: Coin<Ty0>)
3Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
4StLoc[2](loc0: Balance<Ty0>)
5CopyLoc[0](Arg0: &mut Vault)
6ImmBorrowField[1](Vault.id: UID)
7CopyLoc[3](loc1: TypeName)
8Call dynamic_field::exists_<TypeName>(&UID, TypeName): bool
9BrFalse(18)
B1:
10MoveLoc[0](Arg0: &mut Vault)
11MutBorrowField[1](Vault.id: UID)
12MoveLoc[3](loc1: TypeName)
13Call dynamic_field::borrow_mut<TypeName, Balance<Ty0>>(&mut UID, TypeName): &mut Balance<Ty0>
14MoveLoc[2](loc0: Balance<Ty0>)
15Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
16Pop
17Branch(29)
B2:
18Call balance::zero<Ty0>(): Balance<Ty0>
19StLoc[4](loc2: Balance<Ty0>)
20MutBorrowLoc[4](loc2: Balance<Ty0>)
21MoveLoc[2](loc0: Balance<Ty0>)
22Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
23Pop
24MoveLoc[0](Arg0: &mut Vault)
25MutBorrowField[1](Vault.id: UID)
26MoveLoc[3](loc1: TypeName)
27MoveLoc[4](loc2: Balance<Ty0>)
28Call dynamic_field::add<TypeName, Balance<Ty0>>(&mut UID, TypeName, Balance<Ty0>)
B3:
29Ret
}
entry public receive_deposit<Ty0>(Arg0: &mut Vault, Arg1: Receiving<Coin<Ty0>>) {
L2: loc0: Coin<Ty0>
B0:
0CopyLoc[0](Arg0: &mut Vault)
1MutBorrowField[1](Vault.id: UID)
2MoveLoc[1](Arg1: Receiving<Coin<Ty0>>)
3Call transfer::public_receive<Coin<Ty0>>(&mut UID, Receiving<Coin<Ty0>>): Coin<Ty0>
4StLoc[2](loc0: Coin<Ty0>)
5MoveLoc[0](Arg0: &mut Vault)
6MoveLoc[2](loc0: Coin<Ty0>)
7Call deposit<Ty0>(&mut Vault, Coin<Ty0>)
8Ret
}
public withdraw<Ty0>(Arg0: &mut Vault, Arg1: u64, Arg2: &mut TxContext): Coin<Ty0> {
L3: loc0: address
L4: loc1: &VecSet<address>
L5: loc2: TypeName
L6: loc3: &mut Balance<Ty0>
B0:
0CopyLoc[0](Arg0: &mut Vault)
1ImmBorrowField[0](Vault.members: VecSet<address>)
2StLoc[4](loc1: &VecSet<address>)
3CopyLoc[2](Arg2: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6StLoc[3](loc0: address)
7MoveLoc[4](loc1: &VecSet<address>)
8ImmBorrowLoc[3](loc0: address)
9Call vec_set::contains<address>(&VecSet<address>, &address): bool
10BrFalse(12)
B1:
11Branch(18)
B2:
12MoveLoc[0](Arg0: &mut Vault)
13Pop
14MoveLoc[2](Arg2: &mut TxContext)
15Pop
16LdConst[0](u64: 0)
17Abort
B3:
18Call type_name::get<Ty0>(): TypeName
19StLoc[5](loc2: TypeName)
20MoveLoc[0](Arg0: &mut Vault)
21MutBorrowField[1](Vault.id: UID)
22MoveLoc[5](loc2: TypeName)
23Call dynamic_field::borrow_mut<TypeName, Balance<Ty0>>(&mut UID, TypeName): &mut Balance<Ty0>
24StLoc[6](loc3: &mut Balance<Ty0>)
25CopyLoc[6](loc3: &mut Balance<Ty0>)
26FreezeRef
27Call balance::value<Ty0>(&Balance<Ty0>): u64
28CopyLoc[1](Arg1: u64)
29Ge
30BrFalse(32)
B4:
31Branch(38)
B5:
32MoveLoc[6](loc3: &mut Balance<Ty0>)
33Pop
34MoveLoc[2](Arg2: &mut TxContext)
35Pop
36LdConst[1](u64: 1)
37Abort
B6:
38MoveLoc[6](loc3: &mut Balance<Ty0>)
39MoveLoc[1](Arg1: u64)
40Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
41MoveLoc[2](Arg2: &mut TxContext)
42Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
43Ret
}
entry public withdraw_and_receive<Ty0>(Arg0: &mut Vault, Arg1: u64, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut Vault)
1MoveLoc[1](Arg1: u64)
2CopyLoc[2](Arg2: &mut TxContext)
3Call withdraw<Ty0>(&mut Vault, u64, &mut TxContext): Coin<Ty0>
4MoveLoc[2](Arg2: &mut TxContext)
5FreezeRef
6Call tx_context::sender(&TxContext): address
7Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
8Ret
}
Constants [
0 => u64: 0
1 => u64: 1
]
}