Package

// Move bytecode v6
module 76b4c61e6664131b9028c44556a396b35b2d158dccaf31e844e98007d449c695.vault {
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::safe;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct Vault<phantom Ty0> has key {
	id: UID,
	safe: Balance<SAFE>,
	wrapped: Balance<Ty0>
}

struct VaultCreated has copy, drop {
	vault_id: ID
}

struct Wrapped has copy, drop {
	vault_id: ID,
	account: address,
	amount: u64
}

struct Unwrapped has copy, drop {
	vault_id: ID,
	account: address,
	amount: u64
}

struct ReserveAdded has copy, drop {
	vault_id: ID,
	account: address,
	safe_added: u64,
	wrapped_added: u64
}

public create_vault<Ty0>(Arg0: &mut TxContext): ID {
L1:	loc0: Vault<Ty0>
L2:	loc1: ID
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: Call balance::zero<SAFE>(): Balance<SAFE>
	3: Call balance::zero<Ty0>(): Balance<Ty0>
	4: PackGeneric[0](Vault<Ty0>)
	5: StLoc[1](loc0: Vault<Ty0>)
	6: ImmBorrowLoc[1](loc0: Vault<Ty0>)
	7: Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
	8: StLoc[2](loc1: ID)
	9: CopyLoc[2](loc1: ID)
	10: Pack[1](VaultCreated)
	11: Call event::emit<VaultCreated>(VaultCreated)
	12: MoveLoc[1](loc0: Vault<Ty0>)
	13: Call transfer::share_object<Vault<Ty0>>(Vault<Ty0>)
	14: MoveLoc[2](loc1: ID)
	15: Ret
}

public wrap<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: Coin<SAFE>, Arg2: &mut TxContext): Coin<Ty0> {
L3:	loc0: u64
B0:
	0: ImmBorrowLoc[1](Arg1: Coin<SAFE>)
	1: Call coin::value<SAFE>(&Coin<SAFE>): u64
	2: StLoc[3](loc0: u64)
	3: CopyLoc[3](loc0: u64)
	4: LdU64(0)
	5: Gt
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[0](Arg0: &mut Vault<Ty0>)
	9: Pop
	10: MoveLoc[2](Arg2: &mut TxContext)
	11: Pop
	12: LdConst[0](u64: 0)
	13: Abort
B3:
	14: CopyLoc[0](Arg0: &mut Vault<Ty0>)
	15: ImmBorrowFieldGeneric[0](Vault.wrapped: Balance<Ty0>)
	16: Call balance::value<Ty0>(&Balance<Ty0>): u64
	17: CopyLoc[3](loc0: u64)
	18: Ge
	19: BrFalse(21)
B4:
	20: Branch(27)
B5:
	21: MoveLoc[0](Arg0: &mut Vault<Ty0>)
	22: Pop
	23: MoveLoc[2](Arg2: &mut TxContext)
	24: Pop
	25: LdConst[1](u64: 1)
	26: Abort
B6:
	27: CopyLoc[0](Arg0: &mut Vault<Ty0>)
	28: MutBorrowFieldGeneric[1](Vault.safe: Balance<SAFE>)
	29: MoveLoc[1](Arg1: Coin<SAFE>)
	30: Call coin::into_balance<SAFE>(Coin<SAFE>): Balance<SAFE>
	31: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	32: Pop
	33: CopyLoc[0](Arg0: &mut Vault<Ty0>)
	34: FreezeRef
	35: Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
	36: CopyLoc[2](Arg2: &mut TxContext)
	37: FreezeRef
	38: Call tx_context::sender(&TxContext): address
	39: CopyLoc[3](loc0: u64)
	40: Pack[2](Wrapped)
	41: Call event::emit<Wrapped>(Wrapped)
	42: MoveLoc[0](Arg0: &mut Vault<Ty0>)
	43: MutBorrowFieldGeneric[0](Vault.wrapped: Balance<Ty0>)
	44: MoveLoc[3](loc0: u64)
	45: Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
	46: MoveLoc[2](Arg2: &mut TxContext)
	47: Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
	48: Ret
}

public unwrap<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: Coin<Ty0>, Arg2: &mut TxContext): Coin<SAFE> {
L3:	loc0: u64
B0:
	0: ImmBorrowLoc[1](Arg1: Coin<Ty0>)
	1: Call coin::value<Ty0>(&Coin<Ty0>): u64
	2: StLoc[3](loc0: u64)
	3: CopyLoc[3](loc0: u64)
	4: LdU64(0)
	5: Gt
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[0](Arg0: &mut Vault<Ty0>)
	9: Pop
	10: MoveLoc[2](Arg2: &mut TxContext)
	11: Pop
	12: LdConst[0](u64: 0)
	13: Abort
B3:
	14: CopyLoc[0](Arg0: &mut Vault<Ty0>)
	15: ImmBorrowFieldGeneric[1](Vault.safe: Balance<SAFE>)
	16: Call balance::value<SAFE>(&Balance<SAFE>): u64
	17: CopyLoc[3](loc0: u64)
	18: Ge
	19: BrFalse(21)
B4:
	20: Branch(27)
B5:
	21: MoveLoc[0](Arg0: &mut Vault<Ty0>)
	22: Pop
	23: MoveLoc[2](Arg2: &mut TxContext)
	24: Pop
	25: LdConst[1](u64: 1)
	26: Abort
B6:
	27: CopyLoc[0](Arg0: &mut Vault<Ty0>)
	28: MutBorrowFieldGeneric[0](Vault.wrapped: Balance<Ty0>)
	29: MoveLoc[1](Arg1: Coin<Ty0>)
	30: Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
	31: Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
	32: Pop
	33: CopyLoc[0](Arg0: &mut Vault<Ty0>)
	34: FreezeRef
	35: Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
	36: CopyLoc[2](Arg2: &mut TxContext)
	37: FreezeRef
	38: Call tx_context::sender(&TxContext): address
	39: CopyLoc[3](loc0: u64)
	40: Pack[3](Unwrapped)
	41: Call event::emit<Unwrapped>(Unwrapped)
	42: MoveLoc[0](Arg0: &mut Vault<Ty0>)
	43: MutBorrowFieldGeneric[1](Vault.safe: Balance<SAFE>)
	44: MoveLoc[3](loc0: u64)
	45: Call balance::split<SAFE>(&mut Balance<SAFE>, u64): Balance<SAFE>
	46: MoveLoc[2](Arg2: &mut TxContext)
	47: Call coin::from_balance<SAFE>(Balance<SAFE>, &mut TxContext): Coin<SAFE>
	48: Ret
}

public add_reserve<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: Coin<SAFE>, Arg2: Coin<Ty0>, Arg3: &TxContext) {
L4:	loc0: bool
L5:	loc1: u64
L6:	loc2: u64
B0:
	0: ImmBorrowLoc[1](Arg1: Coin<SAFE>)
	1: Call coin::value<SAFE>(&Coin<SAFE>): u64
	2: StLoc[5](loc1: u64)
	3: ImmBorrowLoc[2](Arg2: Coin<Ty0>)
	4: Call coin::value<Ty0>(&Coin<Ty0>): u64
	5: StLoc[6](loc2: u64)
	6: CopyLoc[5](loc1: u64)
	7: LdU64(0)
	8: Gt
	9: BrFalse(13)
B1:
	10: LdTrue
	11: StLoc[4](loc0: bool)
	12: Branch(17)
B2:
	13: CopyLoc[6](loc2: u64)
	14: LdU64(0)
	15: Gt
	16: StLoc[4](loc0: bool)
B3:
	17: MoveLoc[4](loc0: bool)
	18: BrFalse(20)
B4:
	19: Branch(26)
B5:
	20: MoveLoc[0](Arg0: &mut Vault<Ty0>)
	21: Pop
	22: MoveLoc[3](Arg3: &TxContext)
	23: Pop
	24: LdConst[0](u64: 0)
	25: Abort
B6:
	26: CopyLoc[0](Arg0: &mut Vault<Ty0>)
	27: MutBorrowFieldGeneric[1](Vault.safe: Balance<SAFE>)
	28: MoveLoc[1](Arg1: Coin<SAFE>)
	29: Call coin::into_balance<SAFE>(Coin<SAFE>): Balance<SAFE>
	30: Call balance::join<SAFE>(&mut Balance<SAFE>, Balance<SAFE>): u64
	31: Pop
	32: CopyLoc[0](Arg0: &mut Vault<Ty0>)
	33: MutBorrowFieldGeneric[0](Vault.wrapped: Balance<Ty0>)
	34: MoveLoc[2](Arg2: Coin<Ty0>)
	35: Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
	36: Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
	37: Pop
	38: MoveLoc[0](Arg0: &mut Vault<Ty0>)
	39: FreezeRef
	40: Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
	41: MoveLoc[3](Arg3: &TxContext)
	42: Call tx_context::sender(&TxContext): address
	43: MoveLoc[5](loc1: u64)
	44: MoveLoc[6](loc2: u64)
	45: Pack[4](ReserveAdded)
	46: Call event::emit<ReserveAdded>(ReserveAdded)
	47: Ret
}

public reserves<Ty0>(Arg0: &Vault<Ty0>): u64 * u64 {
B0:
	0: CopyLoc[0](Arg0: &Vault<Ty0>)
	1: ImmBorrowFieldGeneric[1](Vault.safe: Balance<SAFE>)
	2: Call balance::value<SAFE>(&Balance<SAFE>): u64
	3: MoveLoc[0](Arg0: &Vault<Ty0>)
	4: ImmBorrowFieldGeneric[0](Vault.wrapped: Balance<Ty0>)
	5: Call balance::value<Ty0>(&Balance<Ty0>): u64
	6: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
]
}