0xa5b1…fec9

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9

The pipeline is behind the chain tip0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9

Everything already published is complete and correct; only newer blocks are missing. The chain summary reports this generation as behind the tip.

Verification

Code hash: 0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9
Status: full match
Provider: disassembly of package 0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9 as `sui replay` fetched it at the version that executed
Compiler
Language: move-disassembly
Bundle: sha1:bf6ae8eded6033df42c84ceb4df3cd80571c08e2

Sources

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/bank.mvb1003 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.bank {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::protocol;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::roles;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::sub_accounts;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
struct BankBalanceUpdateEvent has copy, drop {
	tx_index: u128,
	action: u64,
	src_address: address,
	dest_address: address,
	amount: u128,
	src_balance: u128,
	dest_balance: u128
}
struct WithdrawalStatusUpdateEvent has copy, drop {
	status: bool
}
struct BankAccount has store {
	balance: u128,
	owner: address
}
struct Bank<phantom Ty0> has store, key {
	id: UID,
	accounts: Table<address, BankAccount>,
	coin_balance: Balance<Ty0>,
	is_withdrawal_allowed: bool,
	supported_coin: String
}
entry set_relayer<Ty0>(Arg0: &ExchangeManagerCap, Arg1: &mut ProtocolConfig, Arg2: &mut Bank<Ty0>, Arg3: &mut TxIndexer, Arg4: address) {
L5:	loc0: address
L6:	loc1: u128
B0:
CopyLoc[1](Arg1: &mut ProtocolConfig)
FreezeRef
Call protocol::check_basic(&ProtocolConfig)
CopyLoc[1](Arg1: &mut ProtocolConfig)
FreezeRef
CopyLoc[0](Arg0: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[4](Arg4: address)
LdConst[4](address: 0x00..)
Neq
BrFalse(12)
B1:
Branch(22)
B2:
MoveLoc[3](Arg3: &mut TxIndexer)
Pop
MoveLoc[0](Arg0: &ExchangeManagerCap)
Pop
MoveLoc[1](Arg1: &mut ProtocolConfig)
Pop
MoveLoc[2](Arg2: &mut Bank<Ty0>)
Pop
LdU64(105)
Abort
B3:
CopyLoc[1](Arg1: &mut ProtocolConfig)
FreezeRef
Call protocol::gas_relayer(&ProtocolConfig): address
StLoc[5](loc0: address)
CopyLoc[5](loc0: address)
CopyLoc[4](Arg4: address)
Neq
BrFalse(39)
B4:
MoveLoc[3](Arg3: &mut TxIndexer)
Call sub_accounts::increment_tx_index(&mut TxIndexer): u128
StLoc[6](loc1: u128)
MoveLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[5](loc0: address)
CopyLoc[4](Arg4: address)
MoveLoc[6](loc1: u128)
Call migrate_gas_relayer_balance<Ty0>(&mut Bank<Ty0>, address, address, u128)
Branch(43)
B5:
MoveLoc[3](Arg3: &mut TxIndexer)
Pop
MoveLoc[2](Arg2: &mut Bank<Ty0>)
Pop
B6:
MoveLoc[0](Arg0: &ExchangeManagerCap)
MoveLoc[1](Arg1: &mut ProtocolConfig)
MoveLoc[4](Arg4: address)
Call roles::set_gas_relayer(&ExchangeManagerCap, &mut ProtocolConfig, address)
Ret
}
public set_withdrawal_status<Ty0>(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Bank<Ty0>, Arg3: bool) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[3](Arg3: bool)
MoveLoc[2](Arg2: &mut Bank<Ty0>)
MutBorrowFieldGeneric[0](Bank.is_withdrawal_allowed: bool)
WriteRef
MoveLoc[3](Arg3: bool)
Pack[1](WithdrawalStatusUpdateEvent)
Call event::emit<WithdrawalStatusUpdateEvent>(WithdrawalStatusUpdateEvent)
Ret
}
entry create_bank<Ty0>(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: String, Arg3: &mut TxContext) {
L4:	loc0: Balance<Ty0>
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
Call balance::zero<Ty0>(): Balance<Ty0>
StLoc[4](loc0: Balance<Ty0>)
CopyLoc[3](Arg3: &mut TxContext)
Call object::new(&mut TxContext): UID
MoveLoc[3](Arg3: &mut TxContext)
Call table::new<address, BankAccount>(&mut TxContext): Table<address, BankAccount>
MoveLoc[4](loc0: Balance<Ty0>)
LdTrue
MoveLoc[2](Arg2: String)
PackGeneric[0](Bank<Ty0>)
Call transfer::share_object<Bank<Ty0>>(Bank<Ty0>)
Ret
}
entry deposit<Ty0>(Arg0: &ProtocolConfig, Arg1: &mut Bank<Ty0>, Arg2: &mut TxIndexer, Arg3: vector<u8>, Arg4: address, Arg5: u64, Arg6: Coin<Ty0>, Arg7: &mut TxContext) {
B0:
LdU64(999)
Abort
}
entry deposit_v2<Ty0>(Arg0: &ProtocolConfig, Arg1: &mut Bank<Ty0>, Arg2: &mut TxIndexer, Arg3: address, Arg4: u64, Arg5: Coin<Ty0>, Arg6: &mut TxContext) {
L7:	loc0: Coin<Ty0>
L8:	loc1: u64
L9:	loc2: u128
B0:
MoveLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
CopyLoc[3](Arg3: address)
LdConst[4](address: 0x00..)
Neq
BrFalse(7)
B1:
Branch(15)
B2:
MoveLoc[2](Arg2: &mut TxIndexer)
Pop
MoveLoc[6](Arg6: &mut TxContext)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(105)
Abort
B3:
ImmBorrowLoc[5](Arg5: Coin<Ty0>)
Call coin::value<Ty0>(&Coin<Ty0>): u64
StLoc[8](loc1: u64)
CopyLoc[4](Arg4: u64)
LdU64(0)
Gt
BrFalse(23)
B4:
Branch(31)
B5:
MoveLoc[2](Arg2: &mut TxIndexer)
Pop
MoveLoc[6](Arg6: &mut TxContext)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(1000)
Abort
B6:
CopyLoc[4](Arg4: u64)
CopyLoc[8](loc1: u64)
Le
BrFalse(36)
B7:
Branch(44)
B8:
MoveLoc[2](Arg2: &mut TxIndexer)
Pop
MoveLoc[6](Arg6: &mut TxContext)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(107)
Abort
B9:
MutBorrowLoc[5](Arg5: Coin<Ty0>)
CopyLoc[4](Arg4: u64)
CopyLoc[6](Arg6: &mut TxContext)
Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
StLoc[7](loc0: Coin<Ty0>)
MoveLoc[2](Arg2: &mut TxIndexer)
Call sub_accounts::increment_tx_index(&mut TxIndexer): u128
StLoc[9](loc2: u128)
MoveLoc[1](Arg1: &mut Bank<Ty0>)
MoveLoc[3](Arg3: address)
MoveLoc[7](loc0: Coin<Ty0>)
MoveLoc[9](loc2: u128)
CopyLoc[6](Arg6: &mut TxContext)
FreezeRef
Call deposit_internal<Ty0>(&mut Bank<Ty0>, address, Coin<Ty0>, u128, &TxContext)
MoveLoc[4](Arg4: u64)
MoveLoc[8](loc1: u64)
Lt
BrFalse(69)
B10:
MoveLoc[5](Arg5: Coin<Ty0>)
MoveLoc[6](Arg6: &mut TxContext)
FreezeRef
Call tx_context::sender(&TxContext): address
Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
Branch(73)
B11:
MoveLoc[6](Arg6: &mut TxContext)
Pop
MoveLoc[5](Arg5: Coin<Ty0>)
Call coin::destroy_zero<Ty0>(Coin<Ty0>)
B12:
Ret
}
public(friend) deposit_internal<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address, Arg2: Coin<Ty0>, Arg3: u128, Arg4: &TxContext) {
B0:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MoveLoc[4](Arg4: &TxContext)
Call tx_context::sender(&TxContext): address
MoveLoc[1](Arg1: address)
MoveLoc[2](Arg2: Coin<Ty0>)
MoveLoc[3](Arg3: u128)
Call deposit_with_source<Ty0>(&mut Bank<Ty0>, address, address, Coin<Ty0>, u128)
Ret
}
entry withdraw<Ty0>(Arg0: &ProtocolConfig, Arg1: &mut Bank<Ty0>, Arg2: &mut TxIndexer, Arg3: vector<u8>, Arg4: address, Arg5: u128, Arg6: &mut TxContext) {
B0:
LdU64(999)
Abort
}
entry withdraw_v2<Ty0>(Arg0: &ProtocolConfig, Arg1: &mut Bank<Ty0>, Arg2: &mut TxIndexer, Arg3: address, Arg4: u128, Arg5: &mut TxContext) {
B0:
MoveLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[1](Arg1: &mut Bank<Ty0>)
MoveLoc[2](Arg2: &mut TxIndexer)
CopyLoc[5](Arg5: &mut TxContext)
FreezeRef
Call tx_context::sender(&TxContext): address
CopyLoc[3](Arg3: address)
MoveLoc[4](Arg4: u128)
MoveLoc[5](Arg5: &mut TxContext)
Call withdraw_internal<Ty0>(&mut Bank<Ty0>, &mut TxIndexer, address, address, u128, &mut TxContext): Coin<Ty0>
MoveLoc[3](Arg3: address)
Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
Ret
}
public(friend) withdraw_internal<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: &mut TxIndexer, Arg2: address, Arg3: address, Arg4: u128, Arg5: &mut TxContext): Coin<Ty0> {
L6:	loc0: u128
B0:
MoveLoc[1](Arg1: &mut TxIndexer)
Call sub_accounts::increment_tx_index(&mut TxIndexer): u128
StLoc[6](loc0: u128)
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MoveLoc[2](Arg2: address)
MoveLoc[3](Arg3: address)
MoveLoc[4](Arg4: u128)
MoveLoc[6](loc0: u128)
MoveLoc[5](Arg5: &mut TxContext)
Call withdraw_internal_with_tx_index<Ty0>(&mut Bank<Ty0>, address, address, u128, u128, &mut TxContext): Coin<Ty0>
Ret
}
public(friend) withdraw_internal_with_tx_index<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address, Arg2: address, Arg3: u128, Arg4: u128, Arg5: &mut TxContext): Coin<Ty0> {
L6:	loc0: u128
L7:	loc1: &mut Table<address, BankAccount>
L8:	loc2: u128
L9:	loc3: Coin<Ty0>
L10:	loc4: u128
L11:	loc5: &mut u128
B0:
CopyLoc[2](Arg2: address)
LdConst[4](address: 0x00..)
Neq
BrFalse(5)
B1:
Branch(11)
B2:
MoveLoc[5](Arg5: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
LdU64(105)
Abort
B3:
CopyLoc[0](Arg0: &mut Bank<Ty0>)
ImmBorrowFieldGeneric[0](Bank.is_withdrawal_allowed: bool)
ReadRef
BrFalse(16)
B4:
Branch(22)
B5:
MoveLoc[5](Arg5: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
LdU64(604)
Abort
B6:
CopyLoc[0](Arg0: &mut Bank<Ty0>)
MutBorrowFieldGeneric[1](Bank.accounts: Table<address, BankAccount>)
StLoc[7](loc1: &mut Table<address, BankAccount>)
CopyLoc[7](loc1: &mut Table<address, BankAccount>)
FreezeRef
CopyLoc[1](Arg1: address)
Call table::contains<address, BankAccount>(&Table<address, BankAccount>, address): bool
BrFalse(31)
B7:
Branch(39)
B8:
MoveLoc[5](Arg5: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
MoveLoc[7](loc1: &mut Table<address, BankAccount>)
Pop
LdU64(605)
Abort
B9:
CopyLoc[3](Arg3: u128)
LdU128(0)
Gt
BrFalse(44)
B10:
Branch(52)
B11:
MoveLoc[5](Arg5: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
MoveLoc[7](loc1: &mut Table<address, BankAccount>)
Pop
LdU64(1001)
Abort
B12:
CopyLoc[3](Arg3: u128)
Call library::convert_usdc_to_base_decimals(u128): u128
StLoc[8](loc2: u128)
CopyLoc[7](loc1: &mut Table<address, BankAccount>)
FreezeRef
CopyLoc[2](Arg2: address)
Call table::contains<address, BankAccount>(&Table<address, BankAccount>, address): bool
BrFalse(68)
B13:
CopyLoc[7](loc1: &mut Table<address, BankAccount>)
FreezeRef
CopyLoc[2](Arg2: address)
Call table::borrow<address, BankAccount>(&Table<address, BankAccount>, address): &BankAccount
ImmBorrowField[2](BankAccount.balance: u128)
ReadRef
StLoc[6](loc0: u128)
Branch(70)
B14:
LdU128(0)
StLoc[6](loc0: u128)
B15:
MoveLoc[6](loc0: u128)
StLoc[10](loc4: u128)
MoveLoc[7](loc1: &mut Table<address, BankAccount>)
CopyLoc[1](Arg1: address)
Call table::borrow_mut<address, BankAccount>(&mut Table<address, BankAccount>, address): &mut BankAccount
MutBorrowField[2](BankAccount.balance: u128)
StLoc[11](loc5: &mut u128)
CopyLoc[11](loc5: &mut u128)
ReadRef
CopyLoc[8](loc2: u128)
Ge
BrFalse(83)
B16:
Branch(91)
B17:
MoveLoc[11](loc5: &mut u128)
Pop
MoveLoc[5](Arg5: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
LdU64(603)
Abort
B18:
CopyLoc[11](loc5: &mut u128)
ReadRef
CopyLoc[8](loc2: u128)
Sub
CopyLoc[11](loc5: &mut u128)
WriteRef
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MutBorrowFieldGeneric[2](Bank.coin_balance: Balance<Ty0>)
MoveLoc[3](Arg3: u128)
CastU64
MoveLoc[5](Arg5: &mut TxContext)
Call coin::take<Ty0>(&mut Balance<Ty0>, u64, &mut TxContext): Coin<Ty0>
StLoc[9](loc3: Coin<Ty0>)
MoveLoc[4](Arg4: u128)
LdConst[1](u64: 1)
MoveLoc[1](Arg1: address)
MoveLoc[2](Arg2: address)
MoveLoc[8](loc2: u128)
MoveLoc[11](loc5: &mut u128)
ReadRef
MoveLoc[10](loc4: u128)
Pack[0](BankBalanceUpdateEvent)
Call event::emit<BankBalanceUpdateEvent>(BankBalanceUpdateEvent)
MoveLoc[9](loc3: Coin<Ty0>)
Ret
}
entry withdraw_all<Ty0>(Arg0: &ProtocolConfig, Arg1: &mut Bank<Ty0>, Arg2: &mut TxIndexer, Arg3: vector<u8>, Arg4: address, Arg5: &mut TxContext) {
B0:
LdU64(999)
Abort
}
entry withdraw_all_v2<Ty0>(Arg0: &ProtocolConfig, Arg1: &mut Bank<Ty0>, Arg2: &mut TxIndexer, Arg3: address, Arg4: &mut TxContext) {
B0:
MoveLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[1](Arg1: &mut Bank<Ty0>)
MoveLoc[2](Arg2: &mut TxIndexer)
CopyLoc[4](Arg4: &mut TxContext)
FreezeRef
Call tx_context::sender(&TxContext): address
CopyLoc[3](Arg3: address)
MoveLoc[4](Arg4: &mut TxContext)
Call withdraw_all_internal<Ty0>(&mut Bank<Ty0>, &mut TxIndexer, address, address, &mut TxContext): Coin<Ty0>
MoveLoc[3](Arg3: address)
Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
Ret
}
public(friend) create_account_if_not_exist<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address) {
L2:	loc0: &mut Table<address, BankAccount>
B0:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MutBorrowFieldGeneric[1](Bank.accounts: Table<address, BankAccount>)
StLoc[2](loc0: &mut Table<address, BankAccount>)
CopyLoc[2](loc0: &mut Table<address, BankAccount>)
FreezeRef
CopyLoc[1](Arg1: address)
Call table::contains<address, BankAccount>(&Table<address, BankAccount>, address): bool
Not
BrFalse(16)
B1:
MoveLoc[2](loc0: &mut Table<address, BankAccount>)
CopyLoc[1](Arg1: address)
LdU128(0)
MoveLoc[1](Arg1: address)
Pack[2](BankAccount)
Call table::add<address, BankAccount>(&mut Table<address, BankAccount>, address, BankAccount)
Branch(18)
B2:
MoveLoc[2](loc0: &mut Table<address, BankAccount>)
Pop
B3:
Ret
}
public(friend) deposit_with_source<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address, Arg2: address, Arg3: Coin<Ty0>, Arg4: u128) {
L5:	loc0: &mut Table<address, BankAccount>
L6:	loc1: u64
L7:	loc2: u128
L8:	loc3: &mut u128
L9:	loc4: u128
B0:
CopyLoc[2](Arg2: address)
LdConst[4](address: 0x00..)
Neq
BrFalse(5)
B1:
Branch(9)
B2:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
LdU64(105)
Abort
B3:
CopyLoc[0](Arg0: &mut Bank<Ty0>)
CopyLoc[2](Arg2: address)
Call create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
CopyLoc[0](Arg0: &mut Bank<Ty0>)
CopyLoc[1](Arg1: address)
Call create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
CopyLoc[0](Arg0: &mut Bank<Ty0>)
MutBorrowFieldGeneric[1](Bank.accounts: Table<address, BankAccount>)
StLoc[5](loc0: &mut Table<address, BankAccount>)
CopyLoc[5](loc0: &mut Table<address, BankAccount>)
FreezeRef
CopyLoc[1](Arg1: address)
Call table::borrow<address, BankAccount>(&Table<address, BankAccount>, address): &BankAccount
ImmBorrowField[2](BankAccount.balance: u128)
ReadRef
StLoc[9](loc4: u128)
ImmBorrowLoc[3](Arg3: Coin<Ty0>)
Call coin::value<Ty0>(&Coin<Ty0>): u64
StLoc[6](loc1: u64)
CopyLoc[6](loc1: u64)
LdU64(0)
Gt
BrFalse(33)
B4:
Branch(39)
B5:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
MoveLoc[5](loc0: &mut Table<address, BankAccount>)
Pop
LdU64(1000)
Abort
B6:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MutBorrowFieldGeneric[2](Bank.coin_balance: Balance<Ty0>)
MoveLoc[3](Arg3: Coin<Ty0>)
Call coin::put<Ty0>(&mut Balance<Ty0>, Coin<Ty0>)
MoveLoc[5](loc0: &mut Table<address, BankAccount>)
CopyLoc[2](Arg2: address)
Call table::borrow_mut<address, BankAccount>(&mut Table<address, BankAccount>, address): &mut BankAccount
MutBorrowField[2](BankAccount.balance: u128)
StLoc[8](loc3: &mut u128)
MoveLoc[6](loc1: u64)
CastU128
Call library::convert_usdc_to_base_decimals(u128): u128
StLoc[7](loc2: u128)
CopyLoc[7](loc2: u128)
CopyLoc[8](loc3: &mut u128)
ReadRef
Add
CopyLoc[8](loc3: &mut u128)
WriteRef
MoveLoc[4](Arg4: u128)
LdConst[0](u64: 0)
MoveLoc[1](Arg1: address)
MoveLoc[2](Arg2: address)
MoveLoc[7](loc2: u128)
MoveLoc[9](loc4: u128)
MoveLoc[8](loc3: &mut u128)
ReadRef
Pack[0](BankBalanceUpdateEvent)
Call event::emit<BankBalanceUpdateEvent>(BankBalanceUpdateEvent)
Ret
}
public(friend) transfer<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address, Arg2: address, Arg3: u128, Arg4: u64, Arg5: u128) {
B0:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MoveLoc[1](Arg1: address)
MoveLoc[2](Arg2: address)
MoveLoc[3](Arg3: u128)
MoveLoc[4](Arg4: u64)
MoveLoc[5](Arg5: u128)
LdConst[2](u64: 2)
Call transfer_with_action<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128, u64)
Ret
}
public(friend) transfer_gas_fee<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address, Arg2: address, Arg3: u128, Arg4: u64, Arg5: u128) {
B0:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MoveLoc[1](Arg1: address)
MoveLoc[2](Arg2: address)
MoveLoc[3](Arg3: u128)
MoveLoc[4](Arg4: u64)
MoveLoc[5](Arg5: u128)
LdConst[3](u64: 3)
Call transfer_with_action<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128, u64)
Ret
}
transfer_with_action<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address, Arg2: address, Arg3: u128, Arg4: u64, Arg5: u128, Arg6: u64) {
L7:	loc0: &mut Table<address, BankAccount>
L8:	loc1: &mut u128
L9:	loc2: &mut u128
B0:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MutBorrowFieldGeneric[1](Bank.accounts: Table<address, BankAccount>)
StLoc[7](loc0: &mut Table<address, BankAccount>)
CopyLoc[7](loc0: &mut Table<address, BankAccount>)
CopyLoc[1](Arg1: address)
Call table::borrow_mut<address, BankAccount>(&mut Table<address, BankAccount>, address): &mut BankAccount
MutBorrowField[2](BankAccount.balance: u128)
StLoc[9](loc2: &mut u128)
CopyLoc[9](loc2: &mut u128)
ReadRef
CopyLoc[3](Arg3: u128)
Ge
BrFalse(14)
B1:
Branch(22)
B2:
MoveLoc[9](loc2: &mut u128)
Pop
MoveLoc[7](loc0: &mut Table<address, BankAccount>)
Pop
LdU64(600)
MoveLoc[4](Arg4: u64)
Add
Abort
B3:
CopyLoc[9](loc2: &mut u128)
ReadRef
CopyLoc[3](Arg3: u128)
Sub
MoveLoc[9](loc2: &mut u128)
WriteRef
CopyLoc[7](loc0: &mut Table<address, BankAccount>)
CopyLoc[2](Arg2: address)
Call table::borrow_mut<address, BankAccount>(&mut Table<address, BankAccount>, address): &mut BankAccount
MutBorrowField[2](BankAccount.balance: u128)
StLoc[8](loc1: &mut u128)
CopyLoc[8](loc1: &mut u128)
ReadRef
CopyLoc[3](Arg3: u128)
CastU128
Add
MoveLoc[8](loc1: &mut u128)
WriteRef
MoveLoc[5](Arg5: u128)
MoveLoc[6](Arg6: u64)
CopyLoc[1](Arg1: address)
CopyLoc[2](Arg2: address)
MoveLoc[3](Arg3: u128)
CopyLoc[7](loc0: &mut Table<address, BankAccount>)
FreezeRef
MoveLoc[1](Arg1: address)
Call table::borrow<address, BankAccount>(&Table<address, BankAccount>, address): &BankAccount
ImmBorrowField[2](BankAccount.balance: u128)
ReadRef
MoveLoc[7](loc0: &mut Table<address, BankAccount>)
FreezeRef
MoveLoc[2](Arg2: address)
Call table::borrow<address, BankAccount>(&Table<address, BankAccount>, address): &BankAccount
ImmBorrowField[2](BankAccount.balance: u128)
ReadRef
Pack[0](BankBalanceUpdateEvent)
Call event::emit<BankBalanceUpdateEvent>(BankBalanceUpdateEvent)
Ret
}
public(friend) migrate_gas_relayer_balance<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address, Arg2: address, Arg3: u128) {
L4:	loc0: u128
B0:
CopyLoc[1](Arg1: address)
CopyLoc[2](Arg2: address)
Eq
BrFalse(7)
B1:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
Ret
B2:
CopyLoc[0](Arg0: &mut Bank<Ty0>)
CopyLoc[2](Arg2: address)
Call create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
CopyLoc[0](Arg0: &mut Bank<Ty0>)
FreezeRef
CopyLoc[1](Arg1: address)
Call exists_account<Ty0>(&Bank<Ty0>, address): bool
Not
BrFalse(19)
B3:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
Ret
B4:
CopyLoc[0](Arg0: &mut Bank<Ty0>)
FreezeRef
CopyLoc[1](Arg1: address)
Call get_balance<Ty0>(&Bank<Ty0>, address): u128
StLoc[4](loc0: u128)
CopyLoc[4](loc0: u128)
LdU128(0)
Gt
BrFalse(35)
B5:
CopyLoc[0](Arg0: &mut Bank<Ty0>)
CopyLoc[1](Arg1: address)
MoveLoc[2](Arg2: address)
MoveLoc[4](loc0: u128)
LdU64(2)
MoveLoc[3](Arg3: u128)
Call transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
B6:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MoveLoc[1](Arg1: address)
Call remove_empty_account_internal<Ty0>(&mut Bank<Ty0>, address)
Ret
}
public(friend) charge_relayer_gas_fee<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: &ProtocolConfig, Arg2: address, Arg3: String, Arg4: u128, Arg5: &TxContext) {
L6:	loc0: u128
L7:	loc1: address
B0:
CopyLoc[1](Arg1: &ProtocolConfig)
MoveLoc[3](Arg3: String)
MoveLoc[5](Arg5: &TxContext)
Call protocol::get_action_gas_fee(&ProtocolConfig, String, &TxContext): u128
StLoc[6](loc0: u128)
CopyLoc[6](loc0: u128)
LdU128(0)
Eq
BrFalse(14)
B1:
MoveLoc[1](Arg1: &ProtocolConfig)
Pop
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
Ret
B2:
MoveLoc[1](Arg1: &ProtocolConfig)
Call protocol::gas_relayer(&ProtocolConfig): address
StLoc[7](loc1: address)
CopyLoc[0](Arg0: &mut Bank<Ty0>)
CopyLoc[7](loc1: address)
Call create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MoveLoc[2](Arg2: address)
MoveLoc[7](loc1: address)
MoveLoc[6](loc0: u128)
LdU64(3)
MoveLoc[4](Arg4: u128)
Call transfer_gas_fee<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
Ret
}
public(friend) get_balance<Ty0>(Arg0: &Bank<Ty0>, Arg1: address): u128 {
L2:	loc0: &Table<address, BankAccount>
B0:
MoveLoc[0](Arg0: &Bank<Ty0>)
ImmBorrowFieldGeneric[1](Bank.accounts: Table<address, BankAccount>)
StLoc[2](loc0: &Table<address, BankAccount>)
CopyLoc[2](loc0: &Table<address, BankAccount>)
CopyLoc[1](Arg1: address)
Call table::contains<address, BankAccount>(&Table<address, BankAccount>, address): bool
Not
BrFalse(12)
B1:
MoveLoc[2](loc0: &Table<address, BankAccount>)
Pop
LdU128(0)
Ret
B2:
MoveLoc[2](loc0: &Table<address, BankAccount>)
MoveLoc[1](Arg1: address)
Call table::borrow<address, BankAccount>(&Table<address, BankAccount>, address): &BankAccount
ImmBorrowField[2](BankAccount.balance: u128)
ReadRef
Ret
}
public(friend) is_withdrawal_allowed<Ty0>(Arg0: &Bank<Ty0>): bool {
B0:
MoveLoc[0](Arg0: &Bank<Ty0>)
ImmBorrowFieldGeneric[0](Bank.is_withdrawal_allowed: bool)
ReadRef
Ret
}
public(friend) get_bank_id<Ty0>(Arg0: &Bank<Ty0>): ID {
B0:
MoveLoc[0](Arg0: &Bank<Ty0>)
ImmBorrowFieldGeneric[3](Bank.id: UID)
Call object::uid_to_inner(&UID): ID
Ret
}
public(friend) bank_address<Ty0>(Arg0: &Bank<Ty0>): address {
B0:
MoveLoc[0](Arg0: &Bank<Ty0>)
ImmBorrowFieldGeneric[3](Bank.id: UID)
Call object::uid_to_address(&UID): address
Ret
}
public(friend) withdraw_all_internal<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: &mut TxIndexer, Arg2: address, Arg3: address, Arg4: &mut TxContext): Coin<Ty0> {
L5:	loc0: u128
L6:	loc1: &mut Table<address, BankAccount>
L7:	loc2: u128
L8:	loc3: &mut u128
L9:	loc4: Coin<Ty0>
L10:	loc5: u128
L11:	loc6: u128
L12:	loc7: u128
B0:
CopyLoc[3](Arg3: address)
LdConst[4](address: 0x00..)
Neq
BrFalse(5)
B1:
Branch(13)
B2:
MoveLoc[1](Arg1: &mut TxIndexer)
Pop
MoveLoc[4](Arg4: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
LdU64(105)
Abort
B3:
MoveLoc[1](Arg1: &mut TxIndexer)
Call sub_accounts::increment_tx_index(&mut TxIndexer): u128
StLoc[11](loc6: u128)
CopyLoc[0](Arg0: &mut Bank<Ty0>)
ImmBorrowFieldGeneric[0](Bank.is_withdrawal_allowed: bool)
ReadRef
BrFalse(21)
B4:
Branch(27)
B5:
MoveLoc[4](Arg4: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
LdU64(604)
Abort
B6:
CopyLoc[0](Arg0: &mut Bank<Ty0>)
MutBorrowFieldGeneric[1](Bank.accounts: Table<address, BankAccount>)
StLoc[6](loc1: &mut Table<address, BankAccount>)
CopyLoc[6](loc1: &mut Table<address, BankAccount>)
FreezeRef
CopyLoc[2](Arg2: address)
Call table::contains<address, BankAccount>(&Table<address, BankAccount>, address): bool
BrFalse(36)
B7:
Branch(44)
B8:
MoveLoc[4](Arg4: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
MoveLoc[6](loc1: &mut Table<address, BankAccount>)
Pop
LdU64(605)
Abort
B9:
CopyLoc[6](loc1: &mut Table<address, BankAccount>)
FreezeRef
CopyLoc[3](Arg3: address)
Call table::contains<address, BankAccount>(&Table<address, BankAccount>, address): bool
BrFalse(57)
B10:
CopyLoc[6](loc1: &mut Table<address, BankAccount>)
FreezeRef
CopyLoc[3](Arg3: address)
Call table::borrow<address, BankAccount>(&Table<address, BankAccount>, address): &BankAccount
ImmBorrowField[2](BankAccount.balance: u128)
ReadRef
StLoc[5](loc0: u128)
Branch(59)
B11:
LdU128(0)
StLoc[5](loc0: u128)
B12:
MoveLoc[5](loc0: u128)
StLoc[10](loc5: u128)
CopyLoc[6](loc1: &mut Table<address, BankAccount>)
CopyLoc[2](Arg2: address)
Call table::borrow_mut<address, BankAccount>(&mut Table<address, BankAccount>, address): &mut BankAccount
MutBorrowField[2](BankAccount.balance: u128)
StLoc[8](loc3: &mut u128)
CopyLoc[8](loc3: &mut u128)
ReadRef
LdU128(1000)
Div
StLoc[12](loc7: u128)
CopyLoc[12](loc7: u128)
LdU128(0)
Gt
BrFalse(76)
B13:
Branch(86)
B14:
MoveLoc[4](Arg4: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
MoveLoc[8](loc3: &mut u128)
Pop
MoveLoc[6](loc1: &mut Table<address, BankAccount>)
Pop
LdU64(1001)
Abort
B15:
CopyLoc[12](loc7: u128)
LdU128(1000)
Mul
StLoc[7](loc2: u128)
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MutBorrowFieldGeneric[2](Bank.coin_balance: Balance<Ty0>)
MoveLoc[12](loc7: u128)
CastU64
MoveLoc[4](Arg4: &mut TxContext)
Call coin::take<Ty0>(&mut Balance<Ty0>, u64, &mut TxContext): Coin<Ty0>
StLoc[9](loc4: Coin<Ty0>)
CopyLoc[8](loc3: &mut u128)
ReadRef
CopyLoc[7](loc2: u128)
Sub
MoveLoc[8](loc3: &mut u128)
WriteRef
MoveLoc[11](loc6: u128)
LdConst[1](u64: 1)
CopyLoc[2](Arg2: address)
MoveLoc[3](Arg3: address)
MoveLoc[7](loc2: u128)
MoveLoc[6](loc1: &mut Table<address, BankAccount>)
FreezeRef
MoveLoc[2](Arg2: address)
Call table::borrow<address, BankAccount>(&Table<address, BankAccount>, address): &BankAccount
ImmBorrowField[2](BankAccount.balance: u128)
ReadRef
MoveLoc[10](loc5: u128)
Pack[0](BankBalanceUpdateEvent)
Call event::emit<BankBalanceUpdateEvent>(BankBalanceUpdateEvent)
MoveLoc[9](loc4: Coin<Ty0>)
Ret
}
public(friend) exists_account<Ty0>(Arg0: &Bank<Ty0>, Arg1: address): bool {
B0:
MoveLoc[0](Arg0: &Bank<Ty0>)
ImmBorrowFieldGeneric[1](Bank.accounts: Table<address, BankAccount>)
MoveLoc[1](Arg1: address)
Call table::contains<address, BankAccount>(&Table<address, BankAccount>, address): bool
Ret
}
public remove_empty_account<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address) {
B0:
LdU64(999)
Abort
}
public(friend) remove_empty_account_internal<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address) {
L2:	loc0: &mut Table<address, BankAccount>
B0:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MutBorrowFieldGeneric[1](Bank.accounts: Table<address, BankAccount>)
StLoc[2](loc0: &mut Table<address, BankAccount>)
CopyLoc[2](loc0: &mut Table<address, BankAccount>)
FreezeRef
CopyLoc[1](Arg1: address)
Call table::contains<address, BankAccount>(&Table<address, BankAccount>, address): bool
BrFalse(19)
B1:
MoveLoc[2](loc0: &mut Table<address, BankAccount>)
MoveLoc[1](Arg1: address)
Call table::remove<address, BankAccount>(&mut Table<address, BankAccount>, address): BankAccount
Unpack[2](BankAccount)
Pop
LdU128(0)
Eq
BrFalse(17)
B2:
Branch(21)
B3:
LdU64(607)
Abort
B4:
MoveLoc[2](loc0: &mut Table<address, BankAccount>)
Pop
B5:
Ret
}
Constants [
=> u64: 0
=> u64: 1
=> u64: 2
=> u64: 3
=> address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/evaluator.mvb814 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.evaluator {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
struct MinOrderPriceUpdateEvent has copy, drop {
	id: ID,
	price: u128
}
struct MaxOrderPriceUpdateEvent has copy, drop {
	id: ID,
	price: u128
}
struct StepSizeUpdateEvent has copy, drop {
	id: ID,
	size: u128
}
struct TickSizeUpdateEvent has copy, drop {
	id: ID,
	size: u128
}
struct MtbLongUpdateEvent has copy, drop {
	id: ID,
	mtb: u128
}
struct MtbShortUpdateEvent has copy, drop {
	id: ID,
	mtb: u128
}
struct MaxQtyLimitUpdateEvent has copy, drop {
	id: ID,
	qty: u128
}
struct MaxQtyMarketUpdateEvent has copy, drop {
	id: ID,
	qty: u128
}
struct MinQtyUpdateEvent has copy, drop {
	id: ID,
	qty: u128
}
struct MaxAllowedOIOpenUpdateEvent has copy, drop {
	id: ID,
	max_allowed_oi_open: vector<u128>
}
struct TradeChecks has copy, drop, store {
	min_price: u128,
	max_price: u128,
	tick_size: u128,
	min_qty: u128,
	max_qty_limit: u128,
	max_qty_market: u128,
	step_size: u128,
	mtb_long: u128,
	mtb_short: u128,
	max_allowed_oi_open: vector<u128>
}
public(friend) new_trade_checks(Arg0: u128, Arg1: u128, Arg2: u128, Arg3: u128, Arg4: u128, Arg5: u128, Arg6: u128, Arg7: u128, Arg8: u128, Arg9: vector<u128>): TradeChecks {
L10:	loc0: vector<u128>
L11:	loc1: TradeChecks
B0:
	0: VecPack(2, 0)
	1: StLoc[10](loc0: vector<u128>)
	2: MutBorrowLoc[10](loc0: vector<u128>)
	3: LdU128(0)
	4: VecPushBack(2)
	5: MutBorrowLoc[10](loc0: vector<u128>)
	6: MoveLoc[9](Arg9: vector<u128>)
	7: Call vector::append<u128>(&mut vector<u128>, vector<u128>)
	8: MoveLoc[0](Arg0: u128)
	9: MoveLoc[1](Arg1: u128)
	10: MoveLoc[2](Arg2: u128)
	11: MoveLoc[3](Arg3: u128)
	12: MoveLoc[4](Arg4: u128)
	13: MoveLoc[5](Arg5: u128)
	14: MoveLoc[6](Arg6: u128)
	15: MoveLoc[7](Arg7: u128)
	16: MoveLoc[8](Arg8: u128)
	17: MoveLoc[10](loc0: vector<u128>)
	18: Pack[10](TradeChecks)
	19: StLoc[11](loc1: TradeChecks)
	20: CopyLoc[11](loc1: TradeChecks)
	21: Call verify_pre_init_checks(TradeChecks)
	22: MoveLoc[11](loc1: TradeChecks)
	23: Ret
}
public(friend) tick_size(Arg0: TradeChecks): u128 {
B0:
	0: ImmBorrowLoc[0](Arg0: TradeChecks)
	1: ImmBorrowField[0](TradeChecks.tick_size: u128)
	2: ReadRef
	3: Ret
}
public(friend) set_min_price(Arg0: ID, Arg1: &mut TradeChecks, Arg2: u128) {
B0:
	0: CopyLoc[2](Arg2: u128)
	1: LdU128(0)
	2: Gt
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[1](Arg1: &mut TradeChecks)
	6: Pop
	7: LdU64(1)
	8: Abort
B3:
	9: CopyLoc[2](Arg2: u128)
	10: CopyLoc[1](Arg1: &mut TradeChecks)
	11: ImmBorrowField[1](TradeChecks.max_price: u128)
	12: ReadRef
	13: Lt
	14: BrFalse(16)
B4:
	15: Branch(20)
B5:
	16: MoveLoc[1](Arg1: &mut TradeChecks)
	17: Pop
	18: LdU64(2)
	19: Abort
B6:
	20: CopyLoc[2](Arg2: u128)
	21: MoveLoc[1](Arg1: &mut TradeChecks)
	22: MutBorrowField[2](TradeChecks.min_price: u128)
	23: WriteRef
	24: MoveLoc[0](Arg0: ID)
	25: MoveLoc[2](Arg2: u128)
	26: Pack[0](MinOrderPriceUpdateEvent)
	27: Call event::emit<MinOrderPriceUpdateEvent>(MinOrderPriceUpdateEvent)
	28: Ret
}
public(friend) set_max_price(Arg0: ID, Arg1: &mut TradeChecks, Arg2: u128) {
B0:
	0: CopyLoc[2](Arg2: u128)
	1: CopyLoc[1](Arg1: &mut TradeChecks)
	2: ImmBorrowField[2](TradeChecks.min_price: u128)
	3: ReadRef
	4: Gt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[1](Arg1: &mut TradeChecks)
	8: Pop
	9: LdU64(9)
	10: Abort
B3:
	11: CopyLoc[2](Arg2: u128)
	12: MoveLoc[1](Arg1: &mut TradeChecks)
	13: MutBorrowField[1](TradeChecks.max_price: u128)
	14: WriteRef
	15: MoveLoc[0](Arg0: ID)
	16: MoveLoc[2](Arg2: u128)
	17: Pack[1](MaxOrderPriceUpdateEvent)
	18: Call event::emit<MaxOrderPriceUpdateEvent>(MaxOrderPriceUpdateEvent)
	19: Ret
}
public(friend) set_step_size(Arg0: ID, Arg1: &mut TradeChecks, Arg2: u128) {
B0:
	0: CopyLoc[2](Arg2: u128)
	1: LdU128(0)
	2: Gt
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[1](Arg1: &mut TradeChecks)
	6: Pop
	7: LdU64(10)
	8: Abort
B3:
	9: CopyLoc[2](Arg2: u128)
	10: MoveLoc[1](Arg1: &mut TradeChecks)
	11: MutBorrowField[3](TradeChecks.step_size: u128)
	12: WriteRef
	13: MoveLoc[0](Arg0: ID)
	14: MoveLoc[2](Arg2: u128)
	15: Pack[2](StepSizeUpdateEvent)
	16: Call event::emit<StepSizeUpdateEvent>(StepSizeUpdateEvent)
	17: Ret
}
public(friend) set_tick_size(Arg0: ID, Arg1: &mut TradeChecks, Arg2: u128) {
B0:
	0: CopyLoc[2](Arg2: u128)
	1: LdU128(0)
	2: Gt
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[1](Arg1: &mut TradeChecks)
	6: Pop
	7: LdU64(11)
	8: Abort
B3:
	9: CopyLoc[2](Arg2: u128)
	10: MoveLoc[1](Arg1: &mut TradeChecks)
	11: MutBorrowField[0](TradeChecks.tick_size: u128)
	12: WriteRef
	13: MoveLoc[0](Arg0: ID)
	14: MoveLoc[2](Arg2: u128)
	15: Pack[3](TickSizeUpdateEvent)
	16: Call event::emit<TickSizeUpdateEvent>(TickSizeUpdateEvent)
	17: Ret
}
public(friend) set_mtb_long(Arg0: ID, Arg1: &mut TradeChecks, Arg2: u128) {
B0:
	0: CopyLoc[2](Arg2: u128)
	1: LdU128(0)
	2: Gt
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[1](Arg1: &mut TradeChecks)
	6: Pop
	7: LdU64(12)
	8: Abort
B3:
	9: CopyLoc[2](Arg2: u128)
	10: MoveLoc[1](Arg1: &mut TradeChecks)
	11: MutBorrowField[4](TradeChecks.mtb_long: u128)
	12: WriteRef
	13: MoveLoc[0](Arg0: ID)
	14: MoveLoc[2](Arg2: u128)
	15: Pack[4](MtbLongUpdateEvent)
	16: Call event::emit<MtbLongUpdateEvent>(MtbLongUpdateEvent)
	17: Ret
}
public(friend) set_mtb_short(Arg0: ID, Arg1: &mut TradeChecks, Arg2: u128) {
B0:
	0: CopyLoc[2](Arg2: u128)
	1: LdU128(0)
	2: Gt
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[1](Arg1: &mut TradeChecks)
	6: Pop
	7: LdU64(13)
	8: Abort
B3:
	9: CopyLoc[2](Arg2: u128)
	10: Call library::base_uint(): u128
	11: Lt
	12: BrFalse(14)
B4:
	13: Branch(18)
B5:
	14: MoveLoc[1](Arg1: &mut TradeChecks)
	15: Pop
	16: LdU64(14)
	17: Abort
B6:
	18: CopyLoc[2](Arg2: u128)
	19: MoveLoc[1](Arg1: &mut TradeChecks)
	20: MutBorrowField[5](TradeChecks.mtb_short: u128)
	21: WriteRef
	22: MoveLoc[0](Arg0: ID)
	23: MoveLoc[2](Arg2: u128)
	24: Pack[5](MtbShortUpdateEvent)
	25: Call event::emit<MtbShortUpdateEvent>(MtbShortUpdateEvent)
	26: Ret
}
public(friend) set_max_qty_limit(Arg0: ID, Arg1: &mut TradeChecks, Arg2: u128) {
B0:
	0: CopyLoc[2](Arg2: u128)
	1: CopyLoc[1](Arg1: &mut TradeChecks)
	2: ImmBorrowField[6](TradeChecks.min_qty: u128)
	3: ReadRef
	4: Gt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[1](Arg1: &mut TradeChecks)
	8: Pop
	9: LdU64(15)
	10: Abort
B3:
	11: CopyLoc[2](Arg2: u128)
	12: MoveLoc[1](Arg1: &mut TradeChecks)
	13: MutBorrowField[7](TradeChecks.max_qty_limit: u128)
	14: WriteRef
	15: MoveLoc[0](Arg0: ID)
	16: MoveLoc[2](Arg2: u128)
	17: Pack[6](MaxQtyLimitUpdateEvent)
	18: Call event::emit<MaxQtyLimitUpdateEvent>(MaxQtyLimitUpdateEvent)
	19: Ret
}
public(friend) set_max_qty_market(Arg0: ID, Arg1: &mut TradeChecks, Arg2: u128) {
B0:
	0: CopyLoc[2](Arg2: u128)
	1: CopyLoc[1](Arg1: &mut TradeChecks)
	2: ImmBorrowField[6](TradeChecks.min_qty: u128)
	3: ReadRef
	4: Gt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[1](Arg1: &mut TradeChecks)
	8: Pop
	9: LdU64(16)
	10: Abort
B3:
	11: CopyLoc[2](Arg2: u128)
	12: MoveLoc[1](Arg1: &mut TradeChecks)
	13: MutBorrowField[8](TradeChecks.max_qty_market: u128)
	14: WriteRef
	15: MoveLoc[0](Arg0: ID)
	16: MoveLoc[2](Arg2: u128)
	17: Pack[7](MaxQtyMarketUpdateEvent)
	18: Call event::emit<MaxQtyMarketUpdateEvent>(MaxQtyMarketUpdateEvent)
	19: Ret
}
public(friend) set_min_qty(Arg0: ID, Arg1: &mut TradeChecks, Arg2: u128) {
L3:	loc0: bool
B0:
	0: CopyLoc[2](Arg2: u128)
	1: CopyLoc[1](Arg1: &mut TradeChecks)
	2: ImmBorrowField[7](TradeChecks.max_qty_limit: u128)
	3: ReadRef
	4: Lt
	5: BrFalse(13)
B1:
	6: CopyLoc[2](Arg2: u128)
	7: CopyLoc[1](Arg1: &mut TradeChecks)
	8: ImmBorrowField[8](TradeChecks.max_qty_market: u128)
	9: ReadRef
	10: Lt
	11: StLoc[3](loc0: bool)
	12: Branch(15)
B2:
	13: LdFalse
	14: StLoc[3](loc0: bool)
B3:
	15: MoveLoc[3](loc0: bool)
	16: BrFalse(18)
B4:
	17: Branch(22)
B5:
	18: MoveLoc[1](Arg1: &mut TradeChecks)
	19: Pop
	20: LdU64(17)
	21: Abort
B6:
	22: CopyLoc[2](Arg2: u128)
	23: LdU128(0)
	24: Gt
	25: BrFalse(27)
B7:
	26: Branch(31)
B8:
	27: MoveLoc[1](Arg1: &mut TradeChecks)
	28: Pop
	29: LdU64(18)
	30: Abort
B9:
	31: CopyLoc[2](Arg2: u128)
	32: MoveLoc[1](Arg1: &mut TradeChecks)
	33: MutBorrowField[6](TradeChecks.min_qty: u128)
	34: WriteRef
	35: MoveLoc[0](Arg0: ID)
	36: MoveLoc[2](Arg2: u128)
	37: Pack[8](MinQtyUpdateEvent)
	38: Call event::emit<MinQtyUpdateEvent>(MinQtyUpdateEvent)
	39: Ret
}
public(friend) set_max_oi_open(Arg0: ID, Arg1: &mut TradeChecks, Arg2: vector<u128>) {
L3:	loc0: vector<u128>
B0:
	0: VecPack(2, 0)
	1: StLoc[3](loc0: vector<u128>)
	2: MutBorrowLoc[3](loc0: vector<u128>)
	3: LdU128(0)
	4: VecPushBack(2)
	5: MutBorrowLoc[3](loc0: vector<u128>)
	6: MoveLoc[2](Arg2: vector<u128>)
	7: Call vector::append<u128>(&mut vector<u128>, vector<u128>)
	8: CopyLoc[3](loc0: vector<u128>)
	9: MoveLoc[1](Arg1: &mut TradeChecks)
	10: MutBorrowField[9](TradeChecks.max_allowed_oi_open: vector<u128>)
	11: WriteRef
	12: MoveLoc[0](Arg0: ID)
	13: MoveLoc[3](loc0: vector<u128>)
	14: Pack[9](MaxAllowedOIOpenUpdateEvent)
	15: Call event::emit<MaxAllowedOIOpenUpdateEvent>(MaxAllowedOIOpenUpdateEvent)
	16: Ret
}
verify_pre_init_checks(Arg0: TradeChecks) {
L1:	loc0: bool
B0:
	0: ImmBorrowLoc[0](Arg0: TradeChecks)
	1: ImmBorrowField[2](TradeChecks.min_price: u128)
	2: ReadRef
	3: LdU128(0)
	4: Gt
	5: BrFalse(7)
B1:
	6: Branch(9)
B2:
	7: LdU64(1)
	8: Abort
B3:
	9: ImmBorrowLoc[0](Arg0: TradeChecks)
	10: ImmBorrowField[2](TradeChecks.min_price: u128)
	11: ReadRef
	12: ImmBorrowLoc[0](Arg0: TradeChecks)
	13: ImmBorrowField[1](TradeChecks.max_price: u128)
	14: ReadRef
	15: Lt
	16: BrFalse(18)
B4:
	17: Branch(20)
B5:
	18: LdU64(2)
	19: Abort
B6:
	20: ImmBorrowLoc[0](Arg0: TradeChecks)
	21: ImmBorrowField[3](TradeChecks.step_size: u128)
	22: ReadRef
	23: LdU128(0)
	24: Gt
	25: BrFalse(27)
B7:
	26: Branch(29)
B8:
	27: LdU64(10)
	28: Abort
B9:
	29: ImmBorrowLoc[0](Arg0: TradeChecks)
	30: ImmBorrowField[0](TradeChecks.tick_size: u128)
	31: ReadRef
	32: LdU128(0)
	33: Gt
	34: BrFalse(36)
B10:
	35: Branch(38)
B11:
	36: LdU64(11)
	37: Abort
B12:
	38: ImmBorrowLoc[0](Arg0: TradeChecks)
	39: ImmBorrowField[4](TradeChecks.mtb_long: u128)
	40: ReadRef
	41: LdU128(0)
	42: Gt
	43: BrFalse(45)
B13:
	44: Branch(47)
B14:
	45: LdU64(12)
	46: Abort
B15:
	47: ImmBorrowLoc[0](Arg0: TradeChecks)
	48: ImmBorrowField[5](TradeChecks.mtb_short: u128)
	49: ReadRef
	50: LdU128(0)
	51: Gt
	52: BrFalse(54)
B16:
	53: Branch(56)
B17:
	54: LdU64(13)
	55: Abort
B18:
	56: ImmBorrowLoc[0](Arg0: TradeChecks)
	57: ImmBorrowField[5](TradeChecks.mtb_short: u128)
	58: ReadRef
	59: Call library::base_uint(): u128
	60: Lt
	61: BrFalse(63)
B19:
	62: Branch(65)
B20:
	63: LdU64(14)
	64: Abort
B21:
	65: ImmBorrowLoc[0](Arg0: TradeChecks)
	66: ImmBorrowField[6](TradeChecks.min_qty: u128)
	67: ReadRef
	68: LdU128(0)
	69: Gt
	70: BrFalse(72)
B22:
	71: Branch(74)
B23:
	72: LdU64(18)
	73: Abort
B24:
	74: ImmBorrowLoc[0](Arg0: TradeChecks)
	75: ImmBorrowField[6](TradeChecks.min_qty: u128)
	76: ReadRef
	77: ImmBorrowLoc[0](Arg0: TradeChecks)
	78: ImmBorrowField[7](TradeChecks.max_qty_limit: u128)
	79: ReadRef
	80: Lt
	81: BrFalse(91)
B25:
	82: ImmBorrowLoc[0](Arg0: TradeChecks)
	83: ImmBorrowField[6](TradeChecks.min_qty: u128)
	84: ReadRef
	85: ImmBorrowLoc[0](Arg0: TradeChecks)
	86: ImmBorrowField[8](TradeChecks.max_qty_market: u128)
	87: ReadRef
	88: Lt
	89: StLoc[1](loc0: bool)
	90: Branch(93)
B26:
	91: LdFalse
	92: StLoc[1](loc0: bool)
B27:
	93: MoveLoc[1](loc0: bool)
	94: BrFalse(96)
B28:
	95: Branch(98)
B29:
	96: LdU64(17)
	97: Abort
B30:
	98: Ret
}
public(friend) verify_min_max_price(Arg0: TradeChecks, Arg1: u128) {
B0:
	0: CopyLoc[1](Arg1: u128)
	1: ImmBorrowLoc[0](Arg0: TradeChecks)
	2: ImmBorrowField[2](TradeChecks.min_price: u128)
	3: ReadRef
	4: Ge
	5: BrFalse(7)
B1:
	6: Branch(9)
B2:
	7: LdU64(3)
	8: Abort
B3:
	9: MoveLoc[1](Arg1: u128)
	10: ImmBorrowLoc[0](Arg0: TradeChecks)
	11: ImmBorrowField[1](TradeChecks.max_price: u128)
	12: ReadRef
	13: Le
	14: BrFalse(16)
B4:
	15: Branch(18)
B5:
	16: LdU64(4)
	17: Abort
B6:
	18: Ret
}
public(friend) verify_tick_size(Arg0: TradeChecks, Arg1: u128) {
B0:
	0: MoveLoc[1](Arg1: u128)
	1: ImmBorrowLoc[0](Arg0: TradeChecks)
	2: ImmBorrowField[0](TradeChecks.tick_size: u128)
	3: ReadRef
	4: Mod
	5: LdU128(0)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(11)
B2:
	9: LdU64(5)
	10: Abort
B3:
	11: Ret
}
public(friend) verify_price_checks(Arg0: TradeChecks, Arg1: u128) {
B0:
	0: CopyLoc[0](Arg0: TradeChecks)
	1: CopyLoc[1](Arg1: u128)
	2: Call verify_min_max_price(TradeChecks, u128)
	3: MoveLoc[0](Arg0: TradeChecks)
	4: MoveLoc[1](Arg1: u128)
	5: Call verify_tick_size(TradeChecks, u128)
	6: Ret
}
public(friend) verify_step_size(Arg0: TradeChecks, Arg1: u128) {
B0:
	0: MoveLoc[1](Arg1: u128)
	1: ImmBorrowLoc[0](Arg0: TradeChecks)
	2: ImmBorrowField[3](TradeChecks.step_size: u128)
	3: ReadRef
	4: Mod
	5: LdU128(0)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(11)
B2:
	9: LdU64(22)
	10: Abort
B3:
	11: Ret
}
public(friend) verify_qty_checks(Arg0: TradeChecks, Arg1: u128, Arg2: bool) {
B0:
	0: CopyLoc[1](Arg1: u128)
	1: ImmBorrowLoc[0](Arg0: TradeChecks)
	2: ImmBorrowField[6](TradeChecks.min_qty: u128)
	3: ReadRef
	4: Ge
	5: BrFalse(7)
B1:
	6: Branch(9)
B2:
	7: LdU64(19)
	8: Abort
B3:
	9: CopyLoc[1](Arg1: u128)
	10: ImmBorrowLoc[0](Arg0: TradeChecks)
	11: ImmBorrowField[7](TradeChecks.max_qty_limit: u128)
	12: ReadRef
	13: Le
	14: BrFalse(16)
B4:
	15: Branch(18)
B5:
	16: LdU64(20)
	17: Abort
B6:
	18: MoveLoc[2](Arg2: bool)
	19: BrFalse(29)
B7:
	20: CopyLoc[1](Arg1: u128)
	21: ImmBorrowLoc[0](Arg0: TradeChecks)
	22: ImmBorrowField[8](TradeChecks.max_qty_market: u128)
	23: ReadRef
	24: Le
	25: BrFalse(27)
B8:
	26: Branch(29)
B9:
	27: LdU64(21)
	28: Abort
B10:
	29: MoveLoc[0](Arg0: TradeChecks)
	30: MoveLoc[1](Arg1: u128)
	31: Call verify_step_size(TradeChecks, u128)
	32: Ret
}
public(friend) verify_qty_checks_liquidation(Arg0: TradeChecks, Arg1: u128) {
B0:
	0: CopyLoc[1](Arg1: u128)
	1: ImmBorrowLoc[0](Arg0: TradeChecks)
	2: ImmBorrowField[6](TradeChecks.min_qty: u128)
	3: ReadRef
	4: Ge
	5: BrFalse(7)
B1:
	6: Branch(9)
B2:
	7: LdU64(19)
	8: Abort
B3:
	9: MoveLoc[0](Arg0: TradeChecks)
	10: MoveLoc[1](Arg1: u128)
	11: Call verify_step_size(TradeChecks, u128)
	12: Ret
}
public(friend) verify_market_take_bound_checks(Arg0: TradeChecks, Arg1: u128, Arg2: u128, Arg3: bool) {
B0:
	0: MoveLoc[3](Arg3: bool)
	1: BrFalse(15)
B1:
	2: MoveLoc[1](Arg1: u128)
	3: CopyLoc[2](Arg2: u128)
	4: MoveLoc[2](Arg2: u128)
	5: ImmBorrowLoc[0](Arg0: TradeChecks)
	6: ImmBorrowField[4](TradeChecks.mtb_long: u128)
	7: ReadRef
	8: Call library::base_mul(u128, u128): u128
	9: Add
	10: Le
	11: BrFalse(13)
B2:
	12: Branch(28)
B3:
	13: LdU64(23)
	14: Abort
B4:
	15: MoveLoc[1](Arg1: u128)
	16: CopyLoc[2](Arg2: u128)
	17: MoveLoc[2](Arg2: u128)
	18: ImmBorrowLoc[0](Arg0: TradeChecks)
	19: ImmBorrowField[5](TradeChecks.mtb_short: u128)
	20: ReadRef
	21: Call library::base_mul(u128, u128): u128
	22: Sub
	23: Ge
	24: BrFalse(26)
B5:
	25: Branch(28)
B6:
	26: LdU64(24)
	27: Abort
B7:
	28: Ret
}
public(friend) verify_oi_open_for_account(Arg0: TradeChecks, Arg1: u128, Arg2: u128, Arg3: u64, Arg4: bool) {
L5:	loc0: u128
L6:	loc1: u128
B0:
	0: Call library::base_uint(): u128
	1: MoveLoc[1](Arg1: u128)
	2: Call library::base_div(u128, u128): u128
	3: StLoc[5](loc0: u128)
	4: CopyLoc[5](loc0: u128)
	5: Call library::base_uint(): u128
	6: Mod
	7: Call library::half_base_uint(): u128
	8: Gt
	9: BrFalse(15)
B1:
	10: MoveLoc[5](loc0: u128)
	11: Call library::base_uint(): u128
	12: Call library::ceil(u128, u128): u128
	13: StLoc[5](loc0: u128)
	14: Branch(21)
B2:
	15: MoveLoc[5](loc0: u128)
	16: Call library::base_uint(): u128
	17: Div
	18: Call library::base_uint(): u128
	19: Mul
	20: StLoc[5](loc0: u128)
B3:
	21: MoveLoc[5](loc0: u128)
	22: Call library::base_uint(): u128
	23: Div
	24: StLoc[5](loc0: u128)
	25: CopyLoc[5](loc0: u128)
	26: CastU64
	27: ImmBorrowLoc[0](Arg0: TradeChecks)
	28: ImmBorrowField[9](TradeChecks.max_allowed_oi_open: vector<u128>)
	29: VecLen(2)
	30: Lt
	31: BrFalse(33)
B4:
	32: Branch(37)
B5:
	33: MoveLoc[3](Arg3: u64)
	34: LdU64(40)
	35: Add
	36: Abort
B6:
	37: ImmBorrowLoc[0](Arg0: TradeChecks)
	38: ImmBorrowField[9](TradeChecks.max_allowed_oi_open: vector<u128>)
	39: MoveLoc[5](loc0: u128)
	40: CastU64
	41: VecImmBorrow(2)
	42: ReadRef
	43: StLoc[6](loc1: u128)
	44: MoveLoc[4](Arg4: bool)
	45: BrFalse(50)
B7:
	46: MoveLoc[6](loc1: u128)
	47: LdU128(5)
	48: Mul
	49: StLoc[6](loc1: u128)
B8:
	50: MoveLoc[2](Arg2: u128)
	51: MoveLoc[6](loc1: u128)
	52: Le
	53: BrFalse(55)
B9:
	54: Branch(59)
B10:
	55: MoveLoc[3](Arg3: u64)
	56: LdU64(25)
	57: Add
	58: Abort
B11:
	59: Ret
}
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/exchange.mvb2817 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.exchange {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::bank;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::evaluator;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::funding_rate;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::isolated_adl;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::isolated_liquidation;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::isolated_trading;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::order;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::perpetual;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::position;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::price_feed;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::protocol;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::roles;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::s128;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::settlement;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::sub_accounts;
use 9041eddbe15edba576c8c0bd4237e07b19e2c17fb59b240658f96522261f10c4::payload;
use 9041eddbe15edba576c8c0bd4237e07b19e2c17fb59b240658f96522261f10c4::signature;
use 9041eddbe15edba576c8c0bd4237e07b19e2c17fb59b240658f96522261f10c4::unified_address;
use 8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e::price_info;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct LiquidatorPaidForAccountSettlementEvent has copy, drop {
	tx_index: u128,
	id: ID,
	liquidator: address,
	account: address,
	amount: u128
}
struct SettlementAmountNotPaidCompletelyEvent has copy, drop {
	tx_index: u128,
	account: address,
	amount: u128
}
struct SettlementAmtDueByMakerEvent has copy, drop {
	tx_index: u128,
	account: address,
	amount: u128
}
struct AccountSettlementUpdateEvent has copy, drop {
	tx_index: u128,
	account: address,
	balance: Position,
	settlement_is_positive: bool,
	settlement_amount: u128,
	price: u128,
	funding_rate: S128
}
entry create_perpetual<Ty0>(Arg0: &mut ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Bank<Ty0>, Arg3: vector<u8>, Arg4: u128, Arg5: u128, Arg6: u128, Arg7: u128, Arg8: u128, Arg9: u128, Arg10: u128, Arg11: u128, Arg12: u128, Arg13: vector<u128>, Arg14: u128, Arg15: u128, Arg16: u128, Arg17: u128, Arg18: u128, Arg19: address, Arg20: address, Arg21: address, Arg22: address, Arg23: u64, Arg24: vector<u8>, Arg25: &mut TxContext) {
B0:
LdU64(999)
Abort
}
entry create_perpetual_v2<Ty0>(Arg0: &mut ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Bank<Ty0>, Arg3: &mut PriceFeed, Arg4: vector<u8>, Arg5: u128, Arg6: u128, Arg7: u128, Arg8: u128, Arg9: u128, Arg10: u128, Arg11: u128, Arg12: u128, Arg13: u128, Arg14: vector<u128>, Arg15: u128, Arg16: u128, Arg17: u128, Arg18: u128, Arg19: u128, Arg20: address, Arg21: address, Arg22: address, Arg23: address, Arg24: u64, Arg25: &mut TxContext) {
L26:	loc0: vector<u128>
L27:	loc1: ID
B0:
CopyLoc[0](Arg0: &mut ProtocolConfig)
FreezeRef
Call protocol::check_basic(&ProtocolConfig)
CopyLoc[0](Arg0: &mut ProtocolConfig)
FreezeRef
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[22](Arg22: address)
LdConst[4](address: 0x00..)
Neq
BrFalse(12)
B1:
Branch(22)
B2:
MoveLoc[3](Arg3: &mut PriceFeed)
Pop
MoveLoc[25](Arg25: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut ProtocolConfig)
Pop
MoveLoc[2](Arg2: &mut Bank<Ty0>)
Pop
LdU64(105)
Abort
B3:
CopyLoc[23](Arg23: address)
LdConst[4](address: 0x00..)
Neq
BrFalse(27)
B4:
Branch(37)
B5:
MoveLoc[3](Arg3: &mut PriceFeed)
Pop
MoveLoc[25](Arg25: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut ProtocolConfig)
Pop
MoveLoc[2](Arg2: &mut Bank<Ty0>)
Pop
LdU64(105)
Abort
B6:
MoveLoc[5](Arg5: u128)
Call library::base_uint(): u128
Div
StLoc[5](Arg5: u128)
MoveLoc[6](Arg6: u128)
Call library::base_uint(): u128
Div
StLoc[6](Arg6: u128)
MoveLoc[7](Arg7: u128)
Call library::base_uint(): u128
Div
StLoc[7](Arg7: u128)
MoveLoc[8](Arg8: u128)
Call library::base_uint(): u128
Div
StLoc[8](Arg8: u128)
MoveLoc[9](Arg9: u128)
Call library::base_uint(): u128
Div
StLoc[9](Arg9: u128)
MoveLoc[10](Arg10: u128)
Call library::base_uint(): u128
Div
StLoc[10](Arg10: u128)
MoveLoc[11](Arg11: u128)
Call library::base_uint(): u128
Div
StLoc[11](Arg11: u128)
MoveLoc[12](Arg12: u128)
Call library::base_uint(): u128
Div
StLoc[12](Arg12: u128)
MoveLoc[13](Arg13: u128)
Call library::base_uint(): u128
Div
StLoc[13](Arg13: u128)
MoveLoc[15](Arg15: u128)
Call library::base_uint(): u128
Div
StLoc[15](Arg15: u128)
MoveLoc[16](Arg16: u128)
Call library::base_uint(): u128
Div
StLoc[16](Arg16: u128)
MoveLoc[17](Arg17: u128)
Call library::base_uint(): u128
Div
StLoc[17](Arg17: u128)
MoveLoc[18](Arg18: u128)
Call library::base_uint(): u128
Div
StLoc[18](Arg18: u128)
MoveLoc[19](Arg19: u128)
Call library::base_uint(): u128
Div
StLoc[19](Arg19: u128)
MoveLoc[14](Arg14: vector<u128>)
Call library::to_1x9_vec(vector<u128>): vector<u128>
StLoc[26](loc0: vector<u128>)
MoveLoc[4](Arg4: vector<u8>)
MoveLoc[15](Arg15: u128)
MoveLoc[16](Arg16: u128)
MoveLoc[17](Arg17: u128)
MoveLoc[18](Arg18: u128)
CopyLoc[20](Arg20: address)
CopyLoc[21](Arg21: address)
CopyLoc[22](Arg22: address)
CopyLoc[23](Arg23: address)
MoveLoc[5](Arg5: u128)
MoveLoc[6](Arg6: u128)
MoveLoc[7](Arg7: u128)
MoveLoc[8](Arg8: u128)
MoveLoc[9](Arg9: u128)
MoveLoc[10](Arg10: u128)
MoveLoc[11](Arg11: u128)
MoveLoc[12](Arg12: u128)
MoveLoc[13](Arg13: u128)
MoveLoc[19](Arg19: u128)
MoveLoc[24](Arg24: u64)
MoveLoc[26](loc0: vector<u128>)
LdConst[5](vector<u8>: "" /..)
LdU64(86400000)
LdU128(1000000)
Call library::base_uint(): u128
Mul
MoveLoc[25](Arg25: &mut TxContext)
Call perpetual::create(vector<u8>, u128, u128, u128, u128, address, address, address, address, u128, u128, u128, u128, u128, u128, u128, u128, u128, u128, u64, vector<u128>, vector<u8>, u64, u128, &mut TxContext): ID
StLoc[27](loc1: ID)
MoveLoc[0](Arg0: &mut ProtocolConfig)
CopyLoc[27](loc1: ID)
Call protocol::register_perpetual(&mut ProtocolConfig, ID)
MoveLoc[3](Arg3: &mut PriceFeed)
CopyLoc[27](loc1: ID)
LdU128(0)
LdU64(0)
Call price_feed::insert_price_info(&mut PriceFeed, ID, u128, u64)
CopyLoc[2](Arg2: &mut Bank<Ty0>)
ImmBorrowLoc[27](loc1: ID)
Call object::id_to_address(&ID): address
Call bank::create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
CopyLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[20](Arg20: address)
Call bank::create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
CopyLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[21](Arg21: address)
Call bank::create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
CopyLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[22](Arg22: address)
Call bank::create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
MoveLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[23](Arg23: address)
Call bank::create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
Ret
}
public trade<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut Table<vector<u8>, OrderStatus>, Arg6: &mut TxIndexer, Arg7: &SettlementCap, Arg8: &PriceInfoObject, Arg9: u8, Arg10: u128, Arg11: u128, Arg12: u128, Arg13: u64, Arg14: u128, Arg15: address, Arg16: vector<u8>, Arg17: vector<u8>, Arg18: u8, Arg19: u128, Arg20: u128, Arg21: u128, Arg22: u64, Arg23: u128, Arg24: address, Arg25: vector<u8>, Arg26: vector<u8>, Arg27: u128, Arg28: u128, Arg29: vector<u8>, Arg30: &TxContext) {
B0:
LdU64(999)
Abort
}
public trade_v2<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut Table<vector<u8>, OrderStatus>, Arg6: &mut TxIndexer, Arg7: &SettlementCap, Arg8: &PriceFeed, Arg9: u8, Arg10: u128, Arg11: u128, Arg12: u128, Arg13: u64, Arg14: u128, Arg15: address, Arg16: vector<u8>, Arg17: vector<u8>, Arg18: u8, Arg19: u128, Arg20: u128, Arg21: u128, Arg22: u64, Arg23: u128, Arg24: address, Arg25: vector<u8>, Arg26: vector<u8>, Arg27: u128, Arg28: u128, Arg29: vector<u8>, Arg30: &TxContext) {
B0:
LdU64(999)
Abort
}
verify_user_signature(Arg0: &SubAccounts, Arg1: &UnifiedAddress, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: u64): UnifiedAddress {
B0:
CopyLoc[1](Arg1: &UnifiedAddress)
MoveLoc[0](Arg0: &SubAccounts)
MoveLoc[1](Arg1: &UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
Call sub_accounts::get_all_sub_accounts(&SubAccounts, address): vector<address>
MoveLoc[2](Arg2: vector<u8>)
MoveLoc[3](Arg3: vector<u8>)
MoveLoc[4](Arg4: vector<u8>)
MoveLoc[5](Arg5: u64)
Call signature::verify_user_signature(&UnifiedAddress, vector<address>, vector<u8>, vector<u8>, vector<u8>, u64): UnifiedAddress
Ret
}
public trade_v3<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut Table<vector<u8>, OrderStatus>, Arg6: &mut TxIndexer, Arg7: &SettlementCap, Arg8: &PriceFeed, Arg9: u8, Arg10: u128, Arg11: u128, Arg12: u128, Arg13: u64, Arg14: u128, Arg15: vector<u8>, Arg16: u32, Arg17: vector<u8>, Arg18: vector<u8>, Arg19: u8, Arg20: u128, Arg21: u128, Arg22: u128, Arg23: u64, Arg24: u128, Arg25: vector<u8>, Arg26: u32, Arg27: vector<u8>, Arg28: vector<u8>, Arg29: u128, Arg30: u128, Arg31: vector<u8>, Arg32: &TxContext) {
B0:
LdU64(999)
Abort
}
public trade_v4<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut Table<vector<u8>, OrderStatus>, Arg6: &mut TxIndexer, Arg7: &PriceFeed, Arg8: u8, Arg9: u128, Arg10: u128, Arg11: u128, Arg12: u64, Arg13: u128, Arg14: vector<u8>, Arg15: u32, Arg16: vector<u8>, Arg17: vector<u8>, Arg18: u8, Arg19: u128, Arg20: u128, Arg21: u128, Arg22: u64, Arg23: u128, Arg24: vector<u8>, Arg25: u32, Arg26: vector<u8>, Arg27: vector<u8>, Arg28: u128, Arg29: u128, Arg30: vector<u8>, Arg31: &TxContext) {
L32:	loc0: vector<u8>
L33:	loc1: vector<u8>
L34:	loc2: UnifiedAddress
L35:	loc3: &UnifiedAddress
L36:	loc4: &SubAccounts
L37:	loc5: vector<u8>
L38:	loc6: vector<u8>
L39:	loc7: vector<u8>
L40:	loc8: UnifiedAddress
L41:	loc9: &UnifiedAddress
L42:	loc10: &SubAccounts
L43:	loc11: vector<u8>
L44:	loc12: UnifiedAddress
L45:	loc13: OrderV2
L46:	loc14: UnifiedAddress
L47:	loc15: address
L48:	loc16: UnifiedAddress
L49:	loc17: OrderV2
L50:	loc18: UnifiedAddress
L51:	loc19: u128
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[6](Arg6: &mut TxIndexer)
MoveLoc[30](Arg30: vector<u8>)
Call sub_accounts::validate_unique_tx(&mut TxIndexer, vector<u8>): u128
StLoc[51](loc19: u128)
CopyLoc[2](Arg2: &mut Perpetual)
MoveLoc[7](Arg7: &PriceFeed)
CopyLoc[1](Arg1: &Clock)
Call perpetual::update_oracle_price_v2(&mut Perpetual, &PriceFeed, &Clock)
MoveLoc[14](Arg14: vector<u8>)
Call unified_address::from_tagged_bytes(vector<u8>): UnifiedAddress
StLoc[44](loc12: UnifiedAddress)
MoveLoc[24](Arg24: vector<u8>)
Call unified_address::from_tagged_bytes(vector<u8>): UnifiedAddress
StLoc[48](loc16: UnifiedAddress)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
StLoc[47](loc15: address)
CopyLoc[47](loc15: address)
MoveLoc[8](Arg8: u8)
MoveLoc[9](Arg9: u128)
MoveLoc[10](Arg10: u128)
MoveLoc[11](Arg11: u128)
MoveLoc[44](loc12: UnifiedAddress)
MoveLoc[12](Arg12: u64)
MoveLoc[13](Arg13: u128)
Call order::pack_order(address, u8, u128, u128, u128, UnifiedAddress, u64, u128): OrderV2
StLoc[45](loc13: OrderV2)
MoveLoc[47](loc15: address)
MoveLoc[18](Arg18: u8)
MoveLoc[19](Arg19: u128)
MoveLoc[20](Arg20: u128)
MoveLoc[21](Arg21: u128)
MoveLoc[48](loc16: UnifiedAddress)
MoveLoc[22](Arg22: u64)
MoveLoc[23](Arg23: u128)
Call order::pack_order(address, u8, u128, u128, u128, UnifiedAddress, u64, u128): OrderV2
StLoc[49](loc17: OrderV2)
CopyLoc[4](Arg4: &SubAccounts)
StLoc[42](loc10: &SubAccounts)
CopyLoc[45](loc13: OrderV2)
Call order::creator(OrderV2): UnifiedAddress
StLoc[40](loc8: UnifiedAddress)
ImmBorrowLoc[40](loc8: UnifiedAddress)
StLoc[41](loc9: &UnifiedAddress)
CopyLoc[45](loc13: OrderV2)
CopyLoc[15](Arg15: u32)
Call order::to_json_bytes(OrderV2, u32): vector<u8>
StLoc[39](loc7: vector<u8>)
MoveLoc[16](Arg16: vector<u8>)
StLoc[38](loc6: vector<u8>)
MoveLoc[17](Arg17: vector<u8>)
StLoc[37](loc5: vector<u8>)
MoveLoc[42](loc10: &SubAccounts)
MoveLoc[41](loc9: &UnifiedAddress)
MoveLoc[39](loc7: vector<u8>)
MoveLoc[38](loc6: vector<u8>)
MoveLoc[37](loc5: vector<u8>)
LdU64(30)
Call verify_user_signature(&SubAccounts, &UnifiedAddress, vector<u8>, vector<u8>, vector<u8>, u64): UnifiedAddress
StLoc[46](loc14: UnifiedAddress)
MoveLoc[4](Arg4: &SubAccounts)
StLoc[36](loc4: &SubAccounts)
CopyLoc[49](loc17: OrderV2)
Call order::creator(OrderV2): UnifiedAddress
StLoc[34](loc2: UnifiedAddress)
ImmBorrowLoc[34](loc2: UnifiedAddress)
StLoc[35](loc3: &UnifiedAddress)
CopyLoc[49](loc17: OrderV2)
CopyLoc[25](Arg25: u32)
Call order::to_json_bytes(OrderV2, u32): vector<u8>
StLoc[33](loc1: vector<u8>)
MoveLoc[26](Arg26: vector<u8>)
StLoc[32](loc0: vector<u8>)
MoveLoc[27](Arg27: vector<u8>)
StLoc[43](loc11: vector<u8>)
MoveLoc[36](loc4: &SubAccounts)
MoveLoc[35](loc3: &UnifiedAddress)
MoveLoc[33](loc1: vector<u8>)
MoveLoc[32](loc0: vector<u8>)
MoveLoc[43](loc11: vector<u8>)
LdU64(31)
Call verify_user_signature(&SubAccounts, &UnifiedAddress, vector<u8>, vector<u8>, vector<u8>, u64): UnifiedAddress
StLoc[50](loc18: UnifiedAddress)
CopyLoc[0](Arg0: &ProtocolConfig)
CopyLoc[31](Arg31: &TxContext)
Call tx_context::sender(&TxContext): address
Call roles::check_settlement_sender_validity(&ProtocolConfig, address)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &Clock)
MoveLoc[2](Arg2: &mut Perpetual)
MoveLoc[3](Arg3: &mut Bank<Ty0>)
MoveLoc[5](Arg5: &mut Table<vector<u8>, OrderStatus>)
MoveLoc[51](loc19: u128)
MoveLoc[45](loc13: OrderV2)
MoveLoc[46](loc14: UnifiedAddress)
MoveLoc[15](Arg15: u32)
MoveLoc[49](loc17: OrderV2)
MoveLoc[50](loc18: UnifiedAddress)
MoveLoc[25](Arg25: u32)
MoveLoc[28](Arg28: u128)
MoveLoc[29](Arg29: u128)
MoveLoc[31](Arg31: &TxContext)
Call trade_impl<Ty0>(&ProtocolConfig, &Clock, &mut Perpetual, &mut Bank<Ty0>, &mut Table<vector<u8>, OrderStatus>, u128, OrderV2, UnifiedAddress, u32, OrderV2, UnifiedAddress, u32, u128, u128, &TxContext)
Ret
}
trade_impl<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &mut Table<vector<u8>, OrderStatus>, Arg5: u128, Arg6: OrderV2, Arg7: UnifiedAddress, Arg8: u32, Arg9: OrderV2, Arg10: UnifiedAddress, Arg11: u32, Arg12: u128, Arg13: u128, Arg14: &TxContext) {
L15:	loc0: TradeDataV2
L16:	loc1: u128
L17:	loc2: u128
L18:	loc3: u128
L19:	loc4: address
L20:	loc5: address
L21:	loc6: ID
L22:	loc7: address
L23:	loc8: address
L24:	loc9: u128
L25:	loc10: TradeResponse
B0:
MoveLoc[14](Arg14: &TxContext)
Call tx_context::sender(&TxContext): address
StLoc[22](loc7: address)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::delisted(&Perpetual): bool
Not
BrFalse(9)
B1:
Branch(21)
B2:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[4](Arg4: &mut Table<vector<u8>, OrderStatus>)
Pop
MoveLoc[0](Arg0: &ProtocolConfig)
Pop
MoveLoc[1](Arg1: &Clock)
Pop
MoveLoc[3](Arg3: &mut Bank<Ty0>)
Pop
LdU64(61)
Abort
B3:
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::is_trading_permitted(&Perpetual): bool
BrFalse(26)
B4:
Branch(38)
B5:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[4](Arg4: &mut Table<vector<u8>, OrderStatus>)
Pop
MoveLoc[0](Arg0: &ProtocolConfig)
Pop
MoveLoc[1](Arg1: &Clock)
Pop
MoveLoc[3](Arg3: &mut Bank<Ty0>)
Pop
LdU64(63)
Abort
B6:
CopyLoc[1](Arg1: &Clock)
Call clock::timestamp_ms(&Clock): u64
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::start_time(&Perpetual): u64
Gt
BrFalse(46)
B7:
Branch(58)
B8:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[4](Arg4: &mut Table<vector<u8>, OrderStatus>)
Pop
MoveLoc[0](Arg0: &ProtocolConfig)
Pop
MoveLoc[1](Arg1: &Clock)
Pop
MoveLoc[3](Arg3: &mut Bank<Ty0>)
Pop
LdU64(56)
Abort
B9:
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
StLoc[21](loc6: ID)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
StLoc[20](loc5: address)
ImmBorrowLoc[6](Arg6: OrderV2)
Call order::creator_identifier(&OrderV2): address
StLoc[19](loc4: address)
ImmBorrowLoc[9](Arg9: OrderV2)
Call order::creator_identifier(&OrderV2): address
StLoc[23](loc8: address)
CopyLoc[21](loc6: ID)
CopyLoc[2](Arg2: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[19](loc4: address)
Call position::create_position(ID, &mut Table<address, Position>, address)
MoveLoc[21](loc6: ID)
CopyLoc[2](Arg2: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[23](loc8: address)
Call position::create_position(ID, &mut Table<address, Position>, address)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
FreezeRef
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
CopyLoc[19](loc4: address)
CopyLoc[23](loc8: address)
Call option::some<address>(address): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[18](loc3: u128)
CopyLoc[5](Arg5: u128)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[2](Arg2: &mut Perpetual)
CopyLoc[19](loc4: address)
Call isolated_trading::trade_type(): u8
LdU64(0)
Call apply_funding_rate<Ty0>(u128, &mut Bank<Ty0>, &mut Perpetual, address, u8, u64)
CopyLoc[5](Arg5: u128)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[2](Arg2: &mut Perpetual)
CopyLoc[23](loc8: address)
Call isolated_trading::trade_type(): u8
LdU64(1)
Call apply_funding_rate<Ty0>(u128, &mut Bank<Ty0>, &mut Perpetual, address, u8, u64)
MoveLoc[6](Arg6: OrderV2)
MoveLoc[7](Arg7: UnifiedAddress)
MoveLoc[8](Arg8: u32)
MoveLoc[9](Arg9: OrderV2)
MoveLoc[10](Arg10: UnifiedAddress)
MoveLoc[11](Arg11: u32)
MoveLoc[12](Arg12: u128)
MoveLoc[13](Arg13: u128)
MoveLoc[1](Arg1: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call isolated_trading::pack_trade_data(OrderV2, UnifiedAddress, u32, OrderV2, UnifiedAddress, u32, u128, u128, u64): TradeDataV2
StLoc[15](loc0: TradeDataV2)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[22](loc7: address)
CopyLoc[2](Arg2: &mut Perpetual)
MoveLoc[4](Arg4: &mut Table<vector<u8>, OrderStatus>)
MoveLoc[15](loc0: TradeDataV2)
CopyLoc[5](Arg5: u128)
Call isolated_trading::trade(&ProtocolConfig, address, &mut Perpetual, &mut Table<vector<u8>, OrderStatus>, TradeDataV2, u128): TradeResponse
StLoc[25](loc10: TradeResponse)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[20](loc5: address)
CopyLoc[19](loc4: address)
CopyLoc[23](loc8: address)
CopyLoc[25](loc10: TradeResponse)
Call isolated_trading::maker_funds_flow(TradeResponse): S128
CopyLoc[25](loc10: TradeResponse)
Call isolated_trading::taker_funds_flow(TradeResponse): S128
CopyLoc[5](Arg5: u128)
Call settlement::trade_margin_settlement<Ty0>(&mut Bank<Ty0>, address, address, address, S128, S128, u128)
CopyLoc[25](loc10: TradeResponse)
Call isolated_trading::trade_fee(TradeResponse): u128
StLoc[24](loc9: u128)
CopyLoc[24](loc9: u128)
LdU128(0)
Gt
BrFalse(152)
B10:
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[20](loc5: address)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::fee_pool(&Perpetual): address
MoveLoc[24](loc9: u128)
LdU64(2)
CopyLoc[5](Arg5: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
B11:
MoveLoc[25](loc10: TradeResponse)
Call isolated_trading::gas_fee(TradeResponse): u128
StLoc[17](loc2: u128)
CopyLoc[17](loc2: u128)
LdU128(0)
Gt
BrFalse(168)
B12:
CopyLoc[3](Arg3: &mut Bank<Ty0>)
MoveLoc[20](loc5: address)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::gas_pool(&Perpetual): address
MoveLoc[17](loc2: u128)
LdU64(2)
MoveLoc[5](Arg5: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
B13:
MoveLoc[3](Arg3: &mut Bank<Ty0>)
FreezeRef
MoveLoc[2](Arg2: &mut Perpetual)
FreezeRef
MoveLoc[19](loc4: address)
MoveLoc[23](loc8: address)
Call option::some<address>(address): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[16](loc1: u128)
MoveLoc[18](loc3: u128)
MoveLoc[16](loc1: u128)
Eq
BrFalse(182)
B14:
Branch(184)
B15:
LdU64(99989)
Abort
B16:
Ret
}
public liquidate<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceInfoObject, Arg7: address, Arg8: u128, Arg9: bool, Arg10: vector<u8>, Arg11: &TxContext) {
B0:
LdU64(999)
Abort
}
public liquidate_v2<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceFeed, Arg7: address, Arg8: u128, Arg9: bool, Arg10: vector<u8>, Arg11: &TxContext) {
L12:	loc0: u128
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[5](Arg5: &mut TxIndexer)
MoveLoc[10](Arg10: vector<u8>)
Call sub_accounts::validate_unique_tx(&mut TxIndexer, vector<u8>): u128
StLoc[12](loc0: u128)
MoveLoc[8](Arg8: u128)
Call library::base_uint(): u128
Div
StLoc[8](Arg8: u128)
CopyLoc[2](Arg2: &mut Perpetual)
MoveLoc[6](Arg6: &PriceFeed)
CopyLoc[1](Arg1: &Clock)
Call perpetual::update_oracle_price_v2(&mut Perpetual, &PriceFeed, &Clock)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &Clock)
MoveLoc[2](Arg2: &mut Perpetual)
MoveLoc[3](Arg3: &mut Bank<Ty0>)
MoveLoc[4](Arg4: &SubAccounts)
MoveLoc[12](loc0: u128)
MoveLoc[7](Arg7: address)
MoveLoc[8](Arg8: u128)
MoveLoc[9](Arg9: bool)
MoveLoc[11](Arg11: &TxContext)
Call liquidate_impl<Ty0>(&ProtocolConfig, &Clock, &mut Perpetual, &mut Bank<Ty0>, &SubAccounts, u128, address, u128, bool, &TxContext)
Ret
}
liquidate_impl<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: u128, Arg6: address, Arg7: u128, Arg8: bool, Arg9: &TxContext) {
L10:	loc0: bool
L11:	loc1: TradeData
L12:	loc2: u128
L13:	loc3: u128
L14:	loc4: address
L15:	loc5: address
L16:	loc6: ID
L17:	loc7: S128
L18:	loc8: address
L19:	loc9: u128
L20:	loc10: &mut Position
L21:	loc11: TradeResponse
B0:
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::delisted(&Perpetual): bool
Not
BrFalse(6)
B1:
Branch(18)
B2:
MoveLoc[4](Arg4: &SubAccounts)
Pop
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[9](Arg9: &TxContext)
Pop
MoveLoc[1](Arg1: &Clock)
Pop
MoveLoc[3](Arg3: &mut Bank<Ty0>)
Pop
LdU64(61)
Abort
B3:
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::is_trading_permitted(&Perpetual): bool
BrFalse(23)
B4:
Branch(35)
B5:
MoveLoc[4](Arg4: &SubAccounts)
Pop
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[9](Arg9: &TxContext)
Pop
MoveLoc[1](Arg1: &Clock)
Pop
MoveLoc[3](Arg3: &mut Bank<Ty0>)
Pop
LdU64(63)
Abort
B6:
MoveLoc[1](Arg1: &Clock)
Call clock::timestamp_ms(&Clock): u64
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::start_time(&Perpetual): u64
Gt
BrFalse(43)
B7:
Branch(53)
B8:
MoveLoc[4](Arg4: &SubAccounts)
Pop
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[9](Arg9: &TxContext)
Pop
MoveLoc[3](Arg3: &mut Bank<Ty0>)
Pop
LdU64(56)
Abort
B9:
MoveLoc[9](Arg9: &TxContext)
Call tx_context::sender(&TxContext): address
StLoc[18](loc8: address)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::insurance_active_pool(&Perpetual): address
StLoc[14](loc4: address)
CopyLoc[18](loc8: address)
CopyLoc[14](loc4: address)
Eq
BrFalse(69)
B10:
MoveLoc[4](Arg4: &SubAccounts)
Pop
LdTrue
StLoc[10](loc0: bool)
Branch(74)
B11:
MoveLoc[4](Arg4: &SubAccounts)
CopyLoc[14](loc4: address)
CopyLoc[18](loc8: address)
Call sub_accounts::is_sub_account(&SubAccounts, address, address): bool
StLoc[10](loc0: bool)
B12:
MoveLoc[10](loc0: bool)
BrFalse(77)
B13:
Branch(83)
B14:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[3](Arg3: &mut Bank<Ty0>)
Pop
LdU64(51)
Abort
B15:
CopyLoc[14](loc4: address)
CopyLoc[6](Arg6: address)
Neq
BrFalse(88)
B16:
Branch(94)
B17:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[3](Arg3: &mut Bank<Ty0>)
Pop
LdU64(704)
Abort
B18:
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
StLoc[16](loc6: ID)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
StLoc[15](loc5: address)
CopyLoc[16](loc6: ID)
CopyLoc[2](Arg2: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[6](Arg6: address)
Call position::create_position(ID, &mut Table<address, Position>, address)
MoveLoc[16](loc6: ID)
CopyLoc[2](Arg2: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[14](loc4: address)
Call position::create_position(ID, &mut Table<address, Position>, address)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
FreezeRef
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
CopyLoc[6](Arg6: address)
Call option::none<address>(): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[13](loc3: u128)
CopyLoc[5](Arg5: u128)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[2](Arg2: &mut Perpetual)
CopyLoc[6](Arg6: address)
Call isolated_liquidation::trade_type(): u8
LdU64(0)
Call apply_funding_rate<Ty0>(u128, &mut Bank<Ty0>, &mut Perpetual, address, u8, u64)
CopyLoc[5](Arg5: u128)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[2](Arg2: &mut Perpetual)
CopyLoc[14](loc4: address)
Call isolated_liquidation::trade_type(): u8
LdU64(1)
Call apply_funding_rate<Ty0>(u128, &mut Bank<Ty0>, &mut Perpetual, address, u8, u64)
CopyLoc[2](Arg2: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[14](loc4: address)
Call table::borrow_mut<address, Position>(&mut Table<address, Position>, address): &mut Position
StLoc[20](loc10: &mut Position)
CopyLoc[20](loc10: &mut Position)
FreezeRef
Call position::margin(&Position): u128
StLoc[19](loc9: u128)
CopyLoc[19](loc9: u128)
LdU128(0)
Gt
BrFalse(159)
B19:
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[15](loc5: address)
CopyLoc[14](loc4: address)
MoveLoc[19](loc9: u128)
LdU64(2)
CopyLoc[5](Arg5: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
MoveLoc[20](loc10: &mut Position)
LdU128(0)
Call position::set_margin(&mut Position, u128)
Branch(161)
B20:
MoveLoc[20](loc10: &mut Position)
Pop
B21:
CopyLoc[14](loc4: address)
CopyLoc[6](Arg6: address)
MoveLoc[7](Arg7: u128)
MoveLoc[8](Arg8: bool)
Call isolated_liquidation::pack_trade_data(address, address, u128, bool): TradeData
StLoc[11](loc1: TradeData)
MoveLoc[18](loc8: address)
CopyLoc[2](Arg2: &mut Perpetual)
MoveLoc[11](loc1: TradeData)
CopyLoc[5](Arg5: u128)
Call isolated_liquidation::trade(address, &mut Perpetual, TradeData, u128): TradeResponse
StLoc[21](loc11: TradeResponse)
CopyLoc[21](loc11: TradeResponse)
Call isolated_liquidation::premium(TradeResponse): S128
StLoc[17](loc7: S128)
CopyLoc[17](loc7: S128)
LdU128(0)
Call s128::gt_u128(S128, u128): bool
BrFalse(189)
B22:
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[15](loc5: address)
CopyLoc[14](loc4: address)
MoveLoc[17](loc7: S128)
Call s128::value(S128): u128
LdU64(2)
CopyLoc[5](Arg5: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
Branch(201)
B23:
CopyLoc[17](loc7: S128)
LdU128(0)
Call s128::lt_u128(S128, u128): bool
BrFalse(201)
B24:
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[14](loc4: address)
CopyLoc[15](loc5: address)
MoveLoc[17](loc7: S128)
Call s128::value(S128): u128
LdU64(1)
CopyLoc[5](Arg5: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
B25:
CopyLoc[3](Arg3: &mut Bank<Ty0>)
MoveLoc[15](loc5: address)
CopyLoc[6](Arg6: address)
MoveLoc[14](loc4: address)
CopyLoc[21](loc11: TradeResponse)
Call isolated_liquidation::maker_funds_flow(TradeResponse): S128
MoveLoc[21](loc11: TradeResponse)
Call isolated_liquidation::taker_funds_flow(TradeResponse): S128
MoveLoc[5](Arg5: u128)
Call settlement::trade_margin_settlement<Ty0>(&mut Bank<Ty0>, address, address, address, S128, S128, u128)
MoveLoc[3](Arg3: &mut Bank<Ty0>)
FreezeRef
MoveLoc[2](Arg2: &mut Perpetual)
FreezeRef
MoveLoc[6](Arg6: address)
Call option::none<address>(): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[12](loc2: u128)
MoveLoc[13](loc3: u128)
MoveLoc[12](loc2: u128)
Eq
BrFalse(224)
B26:
Branch(226)
B27:
LdU64(99989)
Abort
B28:
Ret
}
public deleverage<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &mut TxIndexer, Arg5: &DeleveragingCap, Arg6: &PriceInfoObject, Arg7: address, Arg8: address, Arg9: u128, Arg10: bool, Arg11: vector<u8>, Arg12: &TxContext) {
B0:
LdU64(999)
Abort
}
public deleverage_v2<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &mut TxIndexer, Arg5: &DeleveragingCap, Arg6: &PriceFeed, Arg7: address, Arg8: address, Arg9: u128, Arg10: bool, Arg11: vector<u8>, Arg12: &TxContext) {
L13:	loc0: u128
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[4](Arg4: &mut TxIndexer)
MoveLoc[11](Arg11: vector<u8>)
Call sub_accounts::validate_unique_tx(&mut TxIndexer, vector<u8>): u128
StLoc[13](loc0: u128)
MoveLoc[9](Arg9: u128)
Call library::base_uint(): u128
Div
StLoc[9](Arg9: u128)
CopyLoc[2](Arg2: &mut Perpetual)
MoveLoc[6](Arg6: &PriceFeed)
CopyLoc[1](Arg1: &Clock)
Call perpetual::update_oracle_price_v2(&mut Perpetual, &PriceFeed, &Clock)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &Clock)
MoveLoc[2](Arg2: &mut Perpetual)
MoveLoc[3](Arg3: &mut Bank<Ty0>)
MoveLoc[5](Arg5: &DeleveragingCap)
MoveLoc[13](loc0: u128)
MoveLoc[7](Arg7: address)
MoveLoc[8](Arg8: address)
MoveLoc[9](Arg9: u128)
MoveLoc[10](Arg10: bool)
MoveLoc[12](Arg12: &TxContext)
Call deleverage_impl<Ty0>(&ProtocolConfig, &Clock, &mut Perpetual, &mut Bank<Ty0>, &DeleveragingCap, u128, address, address, u128, bool, &TxContext)
Ret
}
deleverage_impl<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &DeleveragingCap, Arg5: u128, Arg6: address, Arg7: address, Arg8: u128, Arg9: bool, Arg10: &TxContext) {
L11:	loc0: TradeData
L12:	loc1: u128
L13:	loc2: u128
L14:	loc3: address
L15:	loc4: ID
L16:	loc5: address
L17:	loc6: TradeResponse
B0:
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::delisted(&Perpetual): bool
Not
BrFalse(6)
B1:
Branch(20)
B2:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[10](Arg10: &TxContext)
Pop
MoveLoc[0](Arg0: &ProtocolConfig)
Pop
MoveLoc[1](Arg1: &Clock)
Pop
MoveLoc[4](Arg4: &DeleveragingCap)
Pop
MoveLoc[3](Arg3: &mut Bank<Ty0>)
Pop
LdU64(61)
Abort
B3:
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::is_trading_permitted(&Perpetual): bool
BrFalse(25)
B4:
Branch(39)
B5:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[10](Arg10: &TxContext)
Pop
MoveLoc[0](Arg0: &ProtocolConfig)
Pop
MoveLoc[1](Arg1: &Clock)
Pop
MoveLoc[4](Arg4: &DeleveragingCap)
Pop
MoveLoc[3](Arg3: &mut Bank<Ty0>)
Pop
LdU64(63)
Abort
B6:
MoveLoc[1](Arg1: &Clock)
Call clock::timestamp_ms(&Clock): u64
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::start_time(&Perpetual): u64
Gt
BrFalse(47)
B7:
Branch(59)
B8:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[10](Arg10: &TxContext)
Pop
MoveLoc[0](Arg0: &ProtocolConfig)
Pop
MoveLoc[4](Arg4: &DeleveragingCap)
Pop
MoveLoc[3](Arg3: &mut Bank<Ty0>)
Pop
LdU64(56)
Abort
B9:
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[4](Arg4: &DeleveragingCap)
Call roles::check_deleveraging_operator_validity(&ProtocolConfig, &DeleveragingCap)
MoveLoc[10](Arg10: &TxContext)
Call tx_context::sender(&TxContext): address
StLoc[16](loc5: address)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
StLoc[15](loc4: ID)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
StLoc[14](loc3: address)
CopyLoc[15](loc4: ID)
CopyLoc[2](Arg2: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[6](Arg6: address)
Call position::create_position(ID, &mut Table<address, Position>, address)
MoveLoc[15](loc4: ID)
CopyLoc[2](Arg2: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[7](Arg7: address)
Call position::create_position(ID, &mut Table<address, Position>, address)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
FreezeRef
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
CopyLoc[6](Arg6: address)
CopyLoc[7](Arg7: address)
Call option::some<address>(address): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[13](loc2: u128)
CopyLoc[5](Arg5: u128)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[2](Arg2: &mut Perpetual)
CopyLoc[6](Arg6: address)
Call isolated_adl::trade_type(): u8
LdU64(0)
Call apply_funding_rate<Ty0>(u128, &mut Bank<Ty0>, &mut Perpetual, address, u8, u64)
CopyLoc[5](Arg5: u128)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[2](Arg2: &mut Perpetual)
CopyLoc[7](Arg7: address)
Call isolated_adl::trade_type(): u8
LdU64(1)
Call apply_funding_rate<Ty0>(u128, &mut Bank<Ty0>, &mut Perpetual, address, u8, u64)
CopyLoc[6](Arg6: address)
CopyLoc[7](Arg7: address)
MoveLoc[8](Arg8: u128)
MoveLoc[9](Arg9: bool)
Call isolated_adl::pack_trade_data(address, address, u128, bool): TradeData
StLoc[11](loc0: TradeData)
MoveLoc[16](loc5: address)
CopyLoc[2](Arg2: &mut Perpetual)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
FreezeRef
MoveLoc[11](loc0: TradeData)
CopyLoc[5](Arg5: u128)
Call isolated_adl::trade<Ty0>(address, &mut Perpetual, &Bank<Ty0>, TradeData, u128): TradeResponse
StLoc[17](loc6: TradeResponse)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
MoveLoc[14](loc3: address)
CopyLoc[6](Arg6: address)
CopyLoc[7](Arg7: address)
CopyLoc[17](loc6: TradeResponse)
Call isolated_adl::maker_funds_flow(TradeResponse): S128
MoveLoc[17](loc6: TradeResponse)
Call isolated_adl::taker_funds_flow(TradeResponse): S128
MoveLoc[5](Arg5: u128)
Call settlement::trade_margin_settlement<Ty0>(&mut Bank<Ty0>, address, address, address, S128, S128, u128)
MoveLoc[3](Arg3: &mut Bank<Ty0>)
FreezeRef
MoveLoc[2](Arg2: &mut Perpetual)
FreezeRef
MoveLoc[6](Arg6: address)
MoveLoc[7](Arg7: address)
Call option::some<address>(address): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[12](loc1: u128)
MoveLoc[13](loc2: u128)
MoveLoc[12](loc1: u128)
Eq
BrFalse(145)
B10:
Branch(147)
B11:
LdU64(99989)
Abort
B12:
Ret
}
public add_margin<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceInfoObject, Arg7: address, Arg8: u128, Arg9: vector<u8>, Arg10: &TxContext) {
B0:
LdU64(999)
Abort
}
public add_margin_v2<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceInfoObject, Arg7: address, Arg8: u128, Arg9: &TxContext) {
B0:
LdU64(999)
Abort
}
public add_margin_v3<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceFeed, Arg7: address, Arg8: u128, Arg9: &TxContext) {
B0:
LdU64(999)
Abort
}
public add_margin_v4<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceFeed, Arg7: vector<u8>, Arg8: u128, Arg9: u128, Arg10: u64, Arg11: vector<u8>, Arg12: vector<u8>, Arg13: &TxContext) {
L14:	loc0: u64
L15:	loc1: &Clock
L16:	loc2: vector<u8>
L17:	loc3: vector<u8>
L18:	loc4: vector<u8>
L19:	loc5: &UnifiedAddress
L20:	loc6: &SubAccounts
L21:	loc7: UnifiedAddress
L22:	loc8: vector<u8>
L23:	loc9: u128
L24:	loc10: UnifiedAddress
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
CopyLoc[1](Arg1: &Clock)
StLoc[15](loc1: &Clock)
CopyLoc[10](Arg10: u64)
StLoc[14](loc0: u64)
MoveLoc[15](loc1: &Clock)
MoveLoc[14](loc0: u64)
LdU64(34)
Call signature::assert_signed_payload_fresh(&Clock, u64, u64)
CopyLoc[2](Arg2: &mut Perpetual)
MoveLoc[6](Arg6: &PriceFeed)
MoveLoc[1](Arg1: &Clock)
Call perpetual::update_oracle_price_v2(&mut Perpetual, &PriceFeed, &Clock)
MoveLoc[7](Arg7: vector<u8>)
Call unified_address::from_tagged_bytes(vector<u8>): UnifiedAddress
StLoc[24](loc10: UnifiedAddress)
CopyLoc[0](Arg0: &ProtocolConfig)
CopyLoc[4](Arg4: &SubAccounts)
ImmBorrowLoc[24](loc10: UnifiedAddress)
CopyLoc[13](Arg13: &TxContext)
Call sub_accounts::assert_signed_action_sender_authorized(&ProtocolConfig, &SubAccounts, &UnifiedAddress, &TxContext)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
CopyLoc[24](loc10: UnifiedAddress)
CopyLoc[8](Arg8: u128)
MoveLoc[9](Arg9: u128)
MoveLoc[10](Arg10: u64)
Call payload::add_margin(address, UnifiedAddress, u128, u128, u64): vector<u8>
StLoc[22](loc8: vector<u8>)
MoveLoc[4](Arg4: &SubAccounts)
StLoc[20](loc6: &SubAccounts)
ImmBorrowLoc[24](loc10: UnifiedAddress)
StLoc[19](loc5: &UnifiedAddress)
CopyLoc[22](loc8: vector<u8>)
StLoc[18](loc4: vector<u8>)
MoveLoc[11](Arg11: vector<u8>)
StLoc[17](loc3: vector<u8>)
MoveLoc[12](Arg12: vector<u8>)
StLoc[16](loc2: vector<u8>)
MoveLoc[20](loc6: &SubAccounts)
MoveLoc[19](loc5: &UnifiedAddress)
MoveLoc[18](loc4: vector<u8>)
MoveLoc[17](loc3: vector<u8>)
MoveLoc[16](loc2: vector<u8>)
LdU64(52)
Call verify_user_signature(&SubAccounts, &UnifiedAddress, vector<u8>, vector<u8>, vector<u8>, u64): UnifiedAddress
StLoc[21](loc7: UnifiedAddress)
MoveLoc[5](Arg5: &mut TxIndexer)
MoveLoc[22](loc8: vector<u8>)
Call library::get_hash(vector<u8>): vector<u8>
Call sub_accounts::validate_unique_tx(&mut TxIndexer, vector<u8>): u128
StLoc[23](loc9: u128)
MoveLoc[8](Arg8: u128)
Call library::base_uint(): u128
Div
StLoc[8](Arg8: u128)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
MoveLoc[0](Arg0: &ProtocolConfig)
ImmBorrowLoc[24](loc10: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
LdConst[6](vector<u8>: "Add..)
Call string::utf8(vector<u8>): String
CopyLoc[23](loc9: u128)
MoveLoc[13](Arg13: &TxContext)
Call bank::charge_relayer_gas_fee<Ty0>(&mut Bank<Ty0>, &ProtocolConfig, address, String, u128, &TxContext)
MoveLoc[2](Arg2: &mut Perpetual)
MoveLoc[3](Arg3: &mut Bank<Ty0>)
MoveLoc[23](loc9: u128)
ImmBorrowLoc[24](loc10: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
MoveLoc[8](Arg8: u128)
ImmBorrowLoc[21](loc7: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
Call add_margin_impl<Ty0>(&mut Perpetual, &mut Bank<Ty0>, u128, address, u128, address)
Ret
}
add_margin_impl<Ty0>(Arg0: &mut Perpetual, Arg1: &mut Bank<Ty0>, Arg2: u128, Arg3: address, Arg4: u128, Arg5: address) {
L6:	loc0: &mut Position
L7:	loc1: u128
L8:	loc2: u128
L9:	loc3: u128
L10:	loc4: address
L11:	loc5: u128
B0:
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
Call perpetual::delisted(&Perpetual): bool
Not
BrFalse(6)
B1:
Branch(12)
B2:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(61)
Abort
B3:
CopyLoc[4](Arg4: u128)
LdU128(0)
Gt
BrFalse(17)
B4:
Branch(23)
B5:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(500)
Abort
B6:
CopyLoc[0](Arg0: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
FreezeRef
CopyLoc[3](Arg3: address)
Call table::contains<address, Position>(&Table<address, Position>, address): bool
BrFalse(30)
B7:
Branch(36)
B8:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(507)
Abort
B9:
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
StLoc[10](loc4: address)
CopyLoc[1](Arg1: &mut Bank<Ty0>)
FreezeRef
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
CopyLoc[3](Arg3: address)
Call option::none<address>(): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[8](loc2: u128)
CopyLoc[0](Arg0: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[3](Arg3: address)
Call table::borrow_mut<address, Position>(&mut Table<address, Position>, address): &mut Position
StLoc[6](loc0: &mut Position)
CopyLoc[6](loc0: &mut Position)
FreezeRef
Call position::size(&Position): u128
StLoc[11](loc5: u128)
CopyLoc[6](loc0: &mut Position)
FreezeRef
Call position::margin(&Position): u128
StLoc[9](loc3: u128)
MoveLoc[11](loc5: u128)
LdU128(0)
Gt
BrFalse(66)
B10:
Branch(74)
B11:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
MoveLoc[6](loc0: &mut Position)
Pop
LdU64(512)
Abort
B12:
CopyLoc[1](Arg1: &mut Bank<Ty0>)
CopyLoc[3](Arg3: address)
MoveLoc[10](loc4: address)
CopyLoc[4](Arg4: u128)
LdU64(3)
CopyLoc[2](Arg2: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
MoveLoc[6](loc0: &mut Position)
MoveLoc[9](loc3: u128)
MoveLoc[4](Arg4: u128)
Add
Call position::set_margin(&mut Position, u128)
CopyLoc[2](Arg2: u128)
CopyLoc[1](Arg1: &mut Bank<Ty0>)
CopyLoc[0](Arg0: &mut Perpetual)
CopyLoc[3](Arg3: address)
LdU8(0)
LdU64(2)
Call apply_funding_rate<Ty0>(u128, &mut Bank<Ty0>, &mut Perpetual, address, u8, u64)
MoveLoc[1](Arg1: &mut Bank<Ty0>)
FreezeRef
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
CopyLoc[3](Arg3: address)
Call option::none<address>(): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[7](loc1: u128)
MoveLoc[8](loc2: u128)
MoveLoc[7](loc1: u128)
Eq
BrFalse(106)
B13:
Branch(110)
B14:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
LdU64(99989)
Abort
B15:
MoveLoc[0](Arg0: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
FreezeRef
MoveLoc[3](Arg3: address)
Call table::borrow<address, Position>(&Table<address, Position>, address): &Position
ReadRef
MoveLoc[5](Arg5: address)
LdConst[0](u8: 1)
MoveLoc[2](Arg2: u128)
Call position::emit_position_update_event(Position, address, u8, u128)
Ret
}
public remove_margin<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceInfoObject, Arg7: address, Arg8: u128, Arg9: vector<u8>, Arg10: &TxContext) {
B0:
LdU64(999)
Abort
}
public remove_margin_v2<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceInfoObject, Arg7: address, Arg8: u128, Arg9: &TxContext) {
B0:
LdU64(999)
Abort
}
public remove_margin_v3<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceFeed, Arg7: address, Arg8: u128, Arg9: &TxContext) {
B0:
LdU64(999)
Abort
}
public remove_margin_v4<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceFeed, Arg7: vector<u8>, Arg8: u128, Arg9: u128, Arg10: u64, Arg11: vector<u8>, Arg12: vector<u8>, Arg13: &TxContext) {
L14:	loc0: u64
L15:	loc1: &Clock
L16:	loc2: vector<u8>
L17:	loc3: vector<u8>
L18:	loc4: vector<u8>
L19:	loc5: &UnifiedAddress
L20:	loc6: &SubAccounts
L21:	loc7: UnifiedAddress
L22:	loc8: vector<u8>
L23:	loc9: u128
L24:	loc10: UnifiedAddress
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
CopyLoc[1](Arg1: &Clock)
StLoc[15](loc1: &Clock)
CopyLoc[10](Arg10: u64)
StLoc[14](loc0: u64)
MoveLoc[15](loc1: &Clock)
MoveLoc[14](loc0: u64)
LdU64(34)
Call signature::assert_signed_payload_fresh(&Clock, u64, u64)
CopyLoc[2](Arg2: &mut Perpetual)
MoveLoc[6](Arg6: &PriceFeed)
MoveLoc[1](Arg1: &Clock)
Call perpetual::update_oracle_price_v2(&mut Perpetual, &PriceFeed, &Clock)
MoveLoc[7](Arg7: vector<u8>)
Call unified_address::from_tagged_bytes(vector<u8>): UnifiedAddress
StLoc[24](loc10: UnifiedAddress)
CopyLoc[0](Arg0: &ProtocolConfig)
CopyLoc[4](Arg4: &SubAccounts)
ImmBorrowLoc[24](loc10: UnifiedAddress)
CopyLoc[13](Arg13: &TxContext)
Call sub_accounts::assert_signed_action_sender_authorized(&ProtocolConfig, &SubAccounts, &UnifiedAddress, &TxContext)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
CopyLoc[24](loc10: UnifiedAddress)
CopyLoc[8](Arg8: u128)
MoveLoc[9](Arg9: u128)
MoveLoc[10](Arg10: u64)
Call payload::remove_margin(address, UnifiedAddress, u128, u128, u64): vector<u8>
StLoc[22](loc8: vector<u8>)
MoveLoc[4](Arg4: &SubAccounts)
StLoc[20](loc6: &SubAccounts)
ImmBorrowLoc[24](loc10: UnifiedAddress)
StLoc[19](loc5: &UnifiedAddress)
CopyLoc[22](loc8: vector<u8>)
StLoc[18](loc4: vector<u8>)
MoveLoc[11](Arg11: vector<u8>)
StLoc[17](loc3: vector<u8>)
MoveLoc[12](Arg12: vector<u8>)
StLoc[16](loc2: vector<u8>)
MoveLoc[20](loc6: &SubAccounts)
MoveLoc[19](loc5: &UnifiedAddress)
MoveLoc[18](loc4: vector<u8>)
MoveLoc[17](loc3: vector<u8>)
MoveLoc[16](loc2: vector<u8>)
LdU64(52)
Call verify_user_signature(&SubAccounts, &UnifiedAddress, vector<u8>, vector<u8>, vector<u8>, u64): UnifiedAddress
StLoc[21](loc7: UnifiedAddress)
MoveLoc[5](Arg5: &mut TxIndexer)
MoveLoc[22](loc8: vector<u8>)
Call library::get_hash(vector<u8>): vector<u8>
Call sub_accounts::validate_unique_tx(&mut TxIndexer, vector<u8>): u128
StLoc[23](loc9: u128)
MoveLoc[8](Arg8: u128)
Call library::base_uint(): u128
Div
StLoc[8](Arg8: u128)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
MoveLoc[0](Arg0: &ProtocolConfig)
ImmBorrowLoc[24](loc10: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
LdConst[7](vector<u8>: "Rem..)
Call string::utf8(vector<u8>): String
CopyLoc[23](loc9: u128)
MoveLoc[13](Arg13: &TxContext)
Call bank::charge_relayer_gas_fee<Ty0>(&mut Bank<Ty0>, &ProtocolConfig, address, String, u128, &TxContext)
MoveLoc[2](Arg2: &mut Perpetual)
MoveLoc[3](Arg3: &mut Bank<Ty0>)
MoveLoc[23](loc9: u128)
ImmBorrowLoc[24](loc10: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
MoveLoc[8](Arg8: u128)
ImmBorrowLoc[21](loc7: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
Call remove_margin_impl<Ty0>(&mut Perpetual, &mut Bank<Ty0>, u128, address, u128, address)
Ret
}
remove_margin_impl<Ty0>(Arg0: &mut Perpetual, Arg1: &mut Bank<Ty0>, Arg2: u128, Arg3: address, Arg4: u128, Arg5: address) {
L6:	loc0: &mut Position
L7:	loc1: Position
L8:	loc2: u128
L9:	loc3: Position
L10:	loc4: u128
L11:	loc5: u128
L12:	loc6: u128
L13:	loc7: address
L14:	loc8: u128
L15:	loc9: u128
B0:
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
Call perpetual::delisted(&Perpetual): bool
Not
BrFalse(6)
B1:
Branch(12)
B2:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(61)
Abort
B3:
CopyLoc[4](Arg4: u128)
LdU128(0)
Gt
BrFalse(17)
B4:
Branch(23)
B5:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(500)
Abort
B6:
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
Call perpetual::price_oracle(&Perpetual): u128
StLoc[14](loc8: u128)
CopyLoc[0](Arg0: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
FreezeRef
CopyLoc[3](Arg3: address)
Call table::contains<address, Position>(&Table<address, Position>, address): bool
BrFalse(34)
B7:
Branch(40)
B8:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(507)
Abort
B9:
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
StLoc[13](loc7: address)
CopyLoc[1](Arg1: &mut Bank<Ty0>)
FreezeRef
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
CopyLoc[3](Arg3: address)
Call option::none<address>(): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[10](loc4: u128)
CopyLoc[0](Arg0: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
FreezeRef
CopyLoc[3](Arg3: address)
Call table::borrow<address, Position>(&Table<address, Position>, address): &Position
ReadRef
StLoc[9](loc3: Position)
CopyLoc[0](Arg0: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[3](Arg3: address)
Call table::borrow_mut<address, Position>(&mut Table<address, Position>, address): &mut Position
StLoc[6](loc0: &mut Position)
CopyLoc[6](loc0: &mut Position)
FreezeRef
Call position::size(&Position): u128
StLoc[15](loc9: u128)
CopyLoc[6](loc0: &mut Position)
FreezeRef
Call position::margin(&Position): u128
StLoc[11](loc5: u128)
MoveLoc[15](loc9: u128)
LdU128(0)
Gt
BrFalse(77)
B10:
Branch(85)
B11:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
MoveLoc[6](loc0: &mut Position)
Pop
LdU64(512)
Abort
B12:
CopyLoc[6](loc0: &mut Position)
ReadRef
CopyLoc[14](loc8: u128)
Call settlement::get_max_removeable_margin(Position, u128): u128
StLoc[12](loc6: u128)
CopyLoc[4](Arg4: u128)
MoveLoc[12](loc6: u128)
Le
BrFalse(95)
B13:
Branch(103)
B14:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
MoveLoc[6](loc0: &mut Position)
Pop
LdU64(503)
Abort
B15:
CopyLoc[1](Arg1: &mut Bank<Ty0>)
MoveLoc[13](loc7: address)
CopyLoc[3](Arg3: address)
CopyLoc[4](Arg4: u128)
LdU64(2)
CopyLoc[2](Arg2: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
MoveLoc[6](loc0: &mut Position)
MoveLoc[11](loc5: u128)
MoveLoc[4](Arg4: u128)
Sub
Call position::set_margin(&mut Position, u128)
CopyLoc[2](Arg2: u128)
CopyLoc[1](Arg1: &mut Bank<Ty0>)
CopyLoc[0](Arg0: &mut Perpetual)
CopyLoc[3](Arg3: address)
LdU8(0)
LdU64(2)
Call apply_funding_rate<Ty0>(u128, &mut Bank<Ty0>, &mut Perpetual, address, u8, u64)
CopyLoc[0](Arg0: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
FreezeRef
CopyLoc[3](Arg3: address)
Call table::borrow<address, Position>(&Table<address, Position>, address): &Position
ReadRef
StLoc[7](loc1: Position)
ImmBorrowLoc[9](loc3: Position)
ImmBorrowLoc[7](loc1: Position)
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
Call perpetual::imr(&Perpetual): u128
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
Call perpetual::mmr(&Perpetual): u128
MoveLoc[14](loc8: u128)
LdU8(0)
LdU64(0)
Call position::verify_collat_checks(&Position, &Position, u128, u128, u128, u8, u64)
MoveLoc[7](loc1: Position)
MoveLoc[5](Arg5: address)
LdConst[1](u8: 2)
MoveLoc[2](Arg2: u128)
Call position::emit_position_update_event(Position, address, u8, u128)
MoveLoc[1](Arg1: &mut Bank<Ty0>)
FreezeRef
MoveLoc[0](Arg0: &mut Perpetual)
FreezeRef
MoveLoc[3](Arg3: address)
Call option::none<address>(): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[8](loc2: u128)
MoveLoc[10](loc4: u128)
MoveLoc[8](loc2: u128)
Eq
BrFalse(159)
B16:
Branch(161)
B17:
LdU64(99989)
Abort
B18:
Ret
}
public adjust_leverage<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceInfoObject, Arg7: address, Arg8: u128, Arg9: vector<u8>, Arg10: &TxContext) {
B0:
LdU64(999)
Abort
}
public adjust_leverage_v2<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceInfoObject, Arg7: address, Arg8: u128, Arg9: &TxContext) {
B0:
LdU64(999)
Abort
}
public adjust_leverage_v3<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceFeed, Arg7: address, Arg8: u128, Arg9: &TxContext) {
B0:
LdU64(999)
Abort
}
public adjust_leverage_v4<Ty0>(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &mut Perpetual, Arg3: &mut Bank<Ty0>, Arg4: &SubAccounts, Arg5: &mut TxIndexer, Arg6: &PriceFeed, Arg7: vector<u8>, Arg8: u128, Arg9: u128, Arg10: u64, Arg11: vector<u8>, Arg12: vector<u8>, Arg13: &TxContext) {
L14:	loc0: u64
L15:	loc1: &Clock
L16:	loc2: vector<u8>
L17:	loc3: vector<u8>
L18:	loc4: vector<u8>
L19:	loc5: &UnifiedAddress
L20:	loc6: &SubAccounts
L21:	loc7: UnifiedAddress
L22:	loc8: vector<u8>
L23:	loc9: u128
L24:	loc10: UnifiedAddress
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
CopyLoc[1](Arg1: &Clock)
StLoc[15](loc1: &Clock)
CopyLoc[10](Arg10: u64)
StLoc[14](loc0: u64)
MoveLoc[15](loc1: &Clock)
MoveLoc[14](loc0: u64)
LdU64(34)
Call signature::assert_signed_payload_fresh(&Clock, u64, u64)
CopyLoc[2](Arg2: &mut Perpetual)
MoveLoc[6](Arg6: &PriceFeed)
MoveLoc[1](Arg1: &Clock)
Call perpetual::update_oracle_price_v2(&mut Perpetual, &PriceFeed, &Clock)
MoveLoc[7](Arg7: vector<u8>)
Call unified_address::from_tagged_bytes(vector<u8>): UnifiedAddress
StLoc[24](loc10: UnifiedAddress)
CopyLoc[0](Arg0: &ProtocolConfig)
CopyLoc[4](Arg4: &SubAccounts)
ImmBorrowLoc[24](loc10: UnifiedAddress)
CopyLoc[13](Arg13: &TxContext)
Call sub_accounts::assert_signed_action_sender_authorized(&ProtocolConfig, &SubAccounts, &UnifiedAddress, &TxContext)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
CopyLoc[24](loc10: UnifiedAddress)
CopyLoc[8](Arg8: u128)
MoveLoc[9](Arg9: u128)
MoveLoc[10](Arg10: u64)
Call payload::adjust_leverage(address, UnifiedAddress, u128, u128, u64): vector<u8>
StLoc[22](loc8: vector<u8>)
MoveLoc[4](Arg4: &SubAccounts)
StLoc[20](loc6: &SubAccounts)
ImmBorrowLoc[24](loc10: UnifiedAddress)
StLoc[19](loc5: &UnifiedAddress)
CopyLoc[22](loc8: vector<u8>)
StLoc[18](loc4: vector<u8>)
MoveLoc[11](Arg11: vector<u8>)
StLoc[17](loc3: vector<u8>)
MoveLoc[12](Arg12: vector<u8>)
StLoc[16](loc2: vector<u8>)
MoveLoc[20](loc6: &SubAccounts)
MoveLoc[19](loc5: &UnifiedAddress)
MoveLoc[18](loc4: vector<u8>)
MoveLoc[17](loc3: vector<u8>)
MoveLoc[16](loc2: vector<u8>)
LdU64(52)
Call verify_user_signature(&SubAccounts, &UnifiedAddress, vector<u8>, vector<u8>, vector<u8>, u64): UnifiedAddress
StLoc[21](loc7: UnifiedAddress)
MoveLoc[5](Arg5: &mut TxIndexer)
MoveLoc[22](loc8: vector<u8>)
Call library::get_hash(vector<u8>): vector<u8>
Call sub_accounts::validate_unique_tx(&mut TxIndexer, vector<u8>): u128
StLoc[23](loc9: u128)
MoveLoc[8](Arg8: u128)
Call library::base_uint(): u128
Div
StLoc[8](Arg8: u128)
CopyLoc[3](Arg3: &mut Bank<Ty0>)
CopyLoc[0](Arg0: &ProtocolConfig)
ImmBorrowLoc[24](loc10: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
LdConst[8](vector<u8>: "Adj..)
Call string::utf8(vector<u8>): String
CopyLoc[23](loc9: u128)
MoveLoc[13](Arg13: &TxContext)
Call bank::charge_relayer_gas_fee<Ty0>(&mut Bank<Ty0>, &ProtocolConfig, address, String, u128, &TxContext)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[2](Arg2: &mut Perpetual)
MoveLoc[3](Arg3: &mut Bank<Ty0>)
MoveLoc[23](loc9: u128)
ImmBorrowLoc[24](loc10: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
MoveLoc[8](Arg8: u128)
ImmBorrowLoc[21](loc7: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
Call adjust_leverage_impl<Ty0>(&ProtocolConfig, &mut Perpetual, &mut Bank<Ty0>, u128, address, u128, address)
Ret
}
adjust_leverage_impl<Ty0>(Arg0: &ProtocolConfig, Arg1: &mut Perpetual, Arg2: &mut Bank<Ty0>, Arg3: u128, Arg4: address, Arg5: u128, Arg6: address) {
L7:	loc0: &mut Position
L8:	loc1: Position
L9:	loc2: u128
L10:	loc3: Position
L11:	loc4: u128
L12:	loc5: u128
L13:	loc6: address
L14:	loc7: u128
L15:	loc8: u128
L16:	loc9: TradeChecks
B0:
CopyLoc[1](Arg1: &mut Perpetual)
FreezeRef
Call perpetual::delisted(&Perpetual): bool
Not
BrFalse(6)
B1:
Branch(14)
B2:
MoveLoc[1](Arg1: &mut Perpetual)
Pop
MoveLoc[0](Arg0: &ProtocolConfig)
Pop
MoveLoc[2](Arg2: &mut Bank<Ty0>)
Pop
LdU64(61)
Abort
B3:
MoveLoc[5](Arg5: u128)
Call library::round_down(u128): u128
StLoc[5](Arg5: u128)
CopyLoc[5](Arg5: u128)
LdU128(0)
Gt
BrFalse(22)
B4:
Branch(30)
B5:
MoveLoc[1](Arg1: &mut Perpetual)
Pop
MoveLoc[0](Arg0: &ProtocolConfig)
Pop
MoveLoc[2](Arg2: &mut Bank<Ty0>)
Pop
LdU64(504)
Abort
B6:
CopyLoc[1](Arg1: &mut Perpetual)
FreezeRef
Call perpetual::price_oracle(&Perpetual): u128
StLoc[14](loc7: u128)
CopyLoc[1](Arg1: &mut Perpetual)
FreezeRef
Call perpetual::checks(&Perpetual): TradeChecks
StLoc[16](loc9: TradeChecks)
CopyLoc[1](Arg1: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
StLoc[13](loc6: address)
CopyLoc[1](Arg1: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
FreezeRef
CopyLoc[4](Arg4: address)
Call table::contains<address, Position>(&Table<address, Position>, address): bool
BrFalse(49)
B7:
Branch(57)
B8:
MoveLoc[1](Arg1: &mut Perpetual)
Pop
MoveLoc[0](Arg0: &ProtocolConfig)
Pop
MoveLoc[2](Arg2: &mut Bank<Ty0>)
Pop
LdU64(507)
Abort
B9:
CopyLoc[2](Arg2: &mut Bank<Ty0>)
FreezeRef
CopyLoc[1](Arg1: &mut Perpetual)
FreezeRef
CopyLoc[4](Arg4: address)
Call option::none<address>(): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[11](loc4: u128)
CopyLoc[3](Arg3: u128)
CopyLoc[2](Arg2: &mut Bank<Ty0>)
CopyLoc[1](Arg1: &mut Perpetual)
CopyLoc[4](Arg4: address)
LdU8(0)
LdU64(2)
Call apply_funding_rate<Ty0>(u128, &mut Bank<Ty0>, &mut Perpetual, address, u8, u64)
CopyLoc[1](Arg1: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
FreezeRef
CopyLoc[4](Arg4: address)
Call table::borrow<address, Position>(&Table<address, Position>, address): &Position
ReadRef
StLoc[10](loc3: Position)
CopyLoc[1](Arg1: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[4](Arg4: address)
Call table::borrow_mut<address, Position>(&mut Table<address, Position>, address): &mut Position
StLoc[7](loc0: &mut Position)
CopyLoc[7](loc0: &mut Position)
FreezeRef
Call position::margin(&Position): u128
StLoc[12](loc5: u128)
CopyLoc[7](loc0: &mut Position)
FreezeRef
CopyLoc[5](Arg5: u128)
CopyLoc[14](loc7: u128)
Call settlement::get_target_margin(&Position, u128, u128): u128
StLoc[15](loc8: u128)
CopyLoc[12](loc5: u128)
CopyLoc[15](loc8: u128)
Gt
BrFalse(108)
B10:
CopyLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[13](loc6: address)
CopyLoc[4](Arg4: address)
MoveLoc[12](loc5: u128)
CopyLoc[15](loc8: u128)
Sub
LdU64(2)
CopyLoc[3](Arg3: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
Branch(121)
B11:
CopyLoc[12](loc5: u128)
CopyLoc[15](loc8: u128)
Lt
BrFalse(121)
B12:
CopyLoc[2](Arg2: &mut Bank<Ty0>)
CopyLoc[4](Arg4: address)
MoveLoc[13](loc6: address)
CopyLoc[15](loc8: u128)
MoveLoc[12](loc5: u128)
Sub
LdU64(3)
CopyLoc[3](Arg3: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
B13:
CopyLoc[7](loc0: &mut Position)
Call library::base_uint(): u128
MoveLoc[5](Arg5: u128)
Call library::base_div(u128, u128): u128
Call position::set_mro(&mut Position, u128)
CopyLoc[7](loc0: &mut Position)
MoveLoc[15](loc8: u128)
Call position::set_margin(&mut Position, u128)
MoveLoc[16](loc9: TradeChecks)
CopyLoc[7](loc0: &mut Position)
FreezeRef
Call position::mro(&Position): u128
MoveLoc[7](loc0: &mut Position)
FreezeRef
Call position::oi_open(&Position): u128
LdU64(0)
MoveLoc[0](Arg0: &ProtocolConfig)
Call protocol::privileged_addresses(&ProtocolConfig): &VecSet<address>
ImmBorrowLoc[4](Arg4: address)
Call vec_set::contains<address>(&VecSet<address>, &address): bool
Call evaluator::verify_oi_open_for_account(TradeChecks, u128, u128, u64, bool)
CopyLoc[1](Arg1: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
FreezeRef
CopyLoc[4](Arg4: address)
Call table::borrow<address, Position>(&Table<address, Position>, address): &Position
ReadRef
StLoc[8](loc1: Position)
ImmBorrowLoc[10](loc3: Position)
ImmBorrowLoc[8](loc1: Position)
CopyLoc[1](Arg1: &mut Perpetual)
FreezeRef
Call perpetual::imr(&Perpetual): u128
CopyLoc[1](Arg1: &mut Perpetual)
FreezeRef
Call perpetual::mmr(&Perpetual): u128
MoveLoc[14](loc7: u128)
LdU8(0)
LdU64(0)
Call position::verify_collat_checks(&Position, &Position, u128, u128, u128, u8, u64)
MoveLoc[8](loc1: Position)
MoveLoc[6](Arg6: address)
LdConst[2](u8: 3)
MoveLoc[3](Arg3: u128)
Call position::emit_position_update_event(Position, address, u8, u128)
MoveLoc[2](Arg2: &mut Bank<Ty0>)
FreezeRef
MoveLoc[1](Arg1: &mut Perpetual)
FreezeRef
MoveLoc[4](Arg4: address)
Call option::none<address>(): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[9](loc2: u128)
MoveLoc[11](loc4: u128)
MoveLoc[9](loc2: u128)
Eq
BrFalse(179)
B14:
Branch(181)
B15:
LdU64(99989)
Abort
B16:
Ret
}
entry cancel_order<Ty0>(Arg0: &ProtocolConfig, Arg1: &mut Bank<Ty0>, Arg2: &SubAccounts, Arg3: &mut TxIndexer, Arg4: &mut Table<vector<u8>, OrderStatus>, Arg5: address, Arg6: u8, Arg7: u128, Arg8: u128, Arg9: u128, Arg10: u64, Arg11: u128, Arg12: vector<u8>, Arg13: u128, Arg14: u64, Arg15: vector<u8>, Arg16: vector<u8>, Arg17: &Clock, Arg18: &TxContext) {
L19:	loc0: u64
L20:	loc1: &Clock
L21:	loc2: vector<u8>
L22:	loc3: vector<u8>
L23:	loc4: vector<u8>
L24:	loc5: &UnifiedAddress
L25:	loc6: &SubAccounts
L26:	loc7: address
L27:	loc8: UnifiedAddress
L28:	loc9: vector<u8>
L29:	loc10: UnifiedAddress
L30:	loc11: vector<u8>
L31:	loc12: u128
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[17](Arg17: &Clock)
StLoc[20](loc1: &Clock)
CopyLoc[14](Arg14: u64)
StLoc[19](loc0: u64)
MoveLoc[20](loc1: &Clock)
MoveLoc[19](loc0: u64)
LdU64(34)
Call signature::assert_signed_payload_fresh(&Clock, u64, u64)
MoveLoc[12](Arg12: vector<u8>)
Call unified_address::from_tagged_bytes(vector<u8>): UnifiedAddress
StLoc[27](loc8: UnifiedAddress)
CopyLoc[0](Arg0: &ProtocolConfig)
CopyLoc[2](Arg2: &SubAccounts)
ImmBorrowLoc[27](loc8: UnifiedAddress)
CopyLoc[18](Arg18: &TxContext)
Call sub_accounts::assert_signed_action_sender_authorized(&ProtocolConfig, &SubAccounts, &UnifiedAddress, &TxContext)
CopyLoc[5](Arg5: address)
CopyLoc[27](loc8: UnifiedAddress)
CopyLoc[6](Arg6: u8)
CopyLoc[7](Arg7: u128)
CopyLoc[8](Arg8: u128)
CopyLoc[9](Arg9: u128)
CopyLoc[10](Arg10: u64)
CopyLoc[11](Arg11: u128)
MoveLoc[13](Arg13: u128)
MoveLoc[14](Arg14: u64)
Call payload::cancel_order(address, UnifiedAddress, u8, u128, u128, u128, u64, u128, u128, u64): vector<u8>
StLoc[30](loc11: vector<u8>)
MoveLoc[2](Arg2: &SubAccounts)
StLoc[25](loc6: &SubAccounts)
ImmBorrowLoc[27](loc8: UnifiedAddress)
StLoc[24](loc5: &UnifiedAddress)
CopyLoc[30](loc11: vector<u8>)
StLoc[23](loc4: vector<u8>)
MoveLoc[15](Arg15: vector<u8>)
StLoc[22](loc3: vector<u8>)
MoveLoc[16](Arg16: vector<u8>)
StLoc[21](loc2: vector<u8>)
MoveLoc[25](loc6: &SubAccounts)
MoveLoc[24](loc5: &UnifiedAddress)
MoveLoc[23](loc4: vector<u8>)
MoveLoc[22](loc3: vector<u8>)
MoveLoc[21](loc2: vector<u8>)
LdU64(52)
Call verify_user_signature(&SubAccounts, &UnifiedAddress, vector<u8>, vector<u8>, vector<u8>, u64): UnifiedAddress
StLoc[29](loc10: UnifiedAddress)
MoveLoc[3](Arg3: &mut TxIndexer)
MoveLoc[30](loc11: vector<u8>)
Call library::get_hash(vector<u8>): vector<u8>
Call sub_accounts::validate_unique_tx(&mut TxIndexer, vector<u8>): u128
StLoc[31](loc12: u128)
MoveLoc[1](Arg1: &mut Bank<Ty0>)
MoveLoc[0](Arg0: &ProtocolConfig)
ImmBorrowLoc[27](loc8: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
LdConst[9](vector<u8>: "Can..)
Call string::utf8(vector<u8>): String
CopyLoc[31](loc12: u128)
MoveLoc[18](Arg18: &TxContext)
Call bank::charge_relayer_gas_fee<Ty0>(&mut Bank<Ty0>, &ProtocolConfig, address, String, u128, &TxContext)
CopyLoc[5](Arg5: address)
MoveLoc[6](Arg6: u8)
MoveLoc[7](Arg7: u128)
MoveLoc[8](Arg8: u128)
MoveLoc[9](Arg9: u128)
MoveLoc[27](loc8: UnifiedAddress)
MoveLoc[10](Arg10: u64)
MoveLoc[11](Arg11: u128)
Call order::pack_order(address, u8, u128, u128, u128, UnifiedAddress, u64, u128): OrderV2
LdU32(2)
Call order::to_json_bytes(OrderV2, u32): vector<u8>
Call library::get_hash(vector<u8>): vector<u8>
StLoc[28](loc9: vector<u8>)
ImmBorrowLoc[29](loc10: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
StLoc[26](loc7: address)
MoveLoc[4](Arg4: &mut Table<vector<u8>, OrderStatus>)
MoveLoc[28](loc9: vector<u8>)
MoveLoc[5](Arg5: address)
MoveLoc[26](loc7: address)
MoveLoc[31](loc12: u128)
Call order::cancel(&mut Table<vector<u8>, OrderStatus>, vector<u8>, address, address, u128)
Ret
}
entry close_position<Ty0>(Arg0: &ProtocolConfig, Arg1: &mut Perpetual, Arg2: &mut Bank<Ty0>, Arg3: &mut TxIndexer, Arg4: vector<u8>, Arg5: &TxContext) {
B0:
LdU64(999)
Abort
}
entry close_position_v2<Ty0>(Arg0: &ProtocolConfig, Arg1: &mut Perpetual, Arg2: &mut Bank<Ty0>, Arg3: &mut TxIndexer, Arg4: &TxContext) {
B0:
LdU64(999)
Abort
}
entry close_position_v3<Ty0>(Arg0: &ProtocolConfig, Arg1: &mut Perpetual, Arg2: &mut Bank<Ty0>, Arg3: &SubAccounts, Arg4: &mut TxIndexer, Arg5: &Clock, Arg6: vector<u8>, Arg7: u128, Arg8: u64, Arg9: vector<u8>, Arg10: vector<u8>, Arg11: &TxContext) {
L12:	loc0: u64
L13:	loc1: &Clock
L14:	loc2: vector<u8>
L15:	loc3: vector<u8>
L16:	loc4: vector<u8>
L17:	loc5: &UnifiedAddress
L18:	loc6: &SubAccounts
L19:	loc7: UnifiedAddress
L20:	loc8: vector<u8>
L21:	loc9: u128
L22:	loc10: UnifiedAddress
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[5](Arg5: &Clock)
StLoc[13](loc1: &Clock)
CopyLoc[8](Arg8: u64)
StLoc[12](loc0: u64)
MoveLoc[13](loc1: &Clock)
MoveLoc[12](loc0: u64)
LdU64(34)
Call signature::assert_signed_payload_fresh(&Clock, u64, u64)
MoveLoc[6](Arg6: vector<u8>)
Call unified_address::from_tagged_bytes(vector<u8>): UnifiedAddress
StLoc[22](loc10: UnifiedAddress)
CopyLoc[0](Arg0: &ProtocolConfig)
CopyLoc[3](Arg3: &SubAccounts)
ImmBorrowLoc[22](loc10: UnifiedAddress)
CopyLoc[11](Arg11: &TxContext)
Call sub_accounts::assert_signed_action_sender_authorized(&ProtocolConfig, &SubAccounts, &UnifiedAddress, &TxContext)
CopyLoc[1](Arg1: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
CopyLoc[22](loc10: UnifiedAddress)
MoveLoc[7](Arg7: u128)
MoveLoc[8](Arg8: u64)
Call payload::close_position(address, UnifiedAddress, u128, u64): vector<u8>
StLoc[20](loc8: vector<u8>)
MoveLoc[3](Arg3: &SubAccounts)
StLoc[18](loc6: &SubAccounts)
ImmBorrowLoc[22](loc10: UnifiedAddress)
StLoc[17](loc5: &UnifiedAddress)
CopyLoc[20](loc8: vector<u8>)
StLoc[16](loc4: vector<u8>)
MoveLoc[9](Arg9: vector<u8>)
StLoc[15](loc3: vector<u8>)
MoveLoc[10](Arg10: vector<u8>)
StLoc[14](loc2: vector<u8>)
MoveLoc[18](loc6: &SubAccounts)
MoveLoc[17](loc5: &UnifiedAddress)
MoveLoc[16](loc4: vector<u8>)
MoveLoc[15](loc3: vector<u8>)
MoveLoc[14](loc2: vector<u8>)
LdU64(52)
Call verify_user_signature(&SubAccounts, &UnifiedAddress, vector<u8>, vector<u8>, vector<u8>, u64): UnifiedAddress
StLoc[19](loc7: UnifiedAddress)
MoveLoc[4](Arg4: &mut TxIndexer)
MoveLoc[20](loc8: vector<u8>)
Call library::get_hash(vector<u8>): vector<u8>
Call sub_accounts::validate_unique_tx(&mut TxIndexer, vector<u8>): u128
StLoc[21](loc9: u128)
CopyLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[0](Arg0: &ProtocolConfig)
ImmBorrowLoc[22](loc10: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
LdConst[10](vector<u8>: "Clo..)
Call string::utf8(vector<u8>): String
CopyLoc[21](loc9: u128)
MoveLoc[11](Arg11: &TxContext)
Call bank::charge_relayer_gas_fee<Ty0>(&mut Bank<Ty0>, &ProtocolConfig, address, String, u128, &TxContext)
MoveLoc[1](Arg1: &mut Perpetual)
MoveLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[21](loc9: u128)
ImmBorrowLoc[22](loc10: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
ImmBorrowLoc[19](loc7: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
Call close_position_impl<Ty0>(&mut Perpetual, &mut Bank<Ty0>, u128, address, address)
Ret
}
close_position_impl<Ty0>(Arg0: &mut Perpetual, Arg1: &mut Bank<Ty0>, Arg2: u128, Arg3: address, Arg4: address) {
L5:	loc0: u128
L6:	loc1: u128
L7:	loc2: u128
L8:	loc3: u128
L9:	loc4: address
L10:	loc5: u128
L11:	loc6: ID
L12:	loc7: &mut Position
B0:
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
Call perpetual::delisted(&Perpetual): bool
BrFalse(5)
B1:
Branch(11)
B2:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(62)
Abort
B3:
CopyLoc[0](Arg0: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
FreezeRef
CopyLoc[3](Arg3: address)
Call table::contains<address, Position>(&Table<address, Position>, address): bool
BrFalse(18)
B4:
Branch(24)
B5:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(507)
Abort
B6:
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
Call perpetual::id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
StLoc[11](loc6: ID)
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
StLoc[9](loc4: address)
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
Call perpetual::delisting_price(&Perpetual): u128
StLoc[5](loc0: u128)
CopyLoc[1](Arg1: &mut Bank<Ty0>)
FreezeRef
CopyLoc[0](Arg0: &mut Perpetual)
FreezeRef
CopyLoc[3](Arg3: address)
Call option::none<address>(): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[7](loc2: u128)
CopyLoc[2](Arg2: u128)
CopyLoc[1](Arg1: &mut Bank<Ty0>)
CopyLoc[0](Arg0: &mut Perpetual)
CopyLoc[3](Arg3: address)
LdU8(0)
LdU64(2)
Call apply_funding_rate<Ty0>(u128, &mut Bank<Ty0>, &mut Perpetual, address, u8, u64)
CopyLoc[0](Arg0: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[3](Arg3: address)
Call table::borrow_mut<address, Position>(&mut Table<address, Position>, address): &mut Position
StLoc[12](loc7: &mut Position)
CopyLoc[12](loc7: &mut Position)
FreezeRef
Call position::size(&Position): u128
LdU128(0)
Gt
BrFalse(64)
B7:
Branch(72)
B8:
MoveLoc[12](loc7: &mut Position)
Pop
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(512)
Abort
B9:
CopyLoc[1](Arg1: &mut Bank<Ty0>)
FreezeRef
CopyLoc[9](loc4: address)
Call bank::get_balance<Ty0>(&Bank<Ty0>, address): u128
StLoc[10](loc5: u128)
CopyLoc[12](loc7: &mut Position)
FreezeRef
MoveLoc[5](loc0: u128)
MoveLoc[10](loc5: u128)
Call settlement::get_margin_left(&Position, u128, u128): u128
StLoc[8](loc3: u128)
CopyLoc[12](loc7: &mut Position)
LdU128(0)
Call position::set_size(&mut Position, u128)
CopyLoc[1](Arg1: &mut Bank<Ty0>)
MoveLoc[9](loc4: address)
CopyLoc[3](Arg3: address)
CopyLoc[8](loc3: u128)
LdU64(2)
CopyLoc[2](Arg2: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
MoveLoc[11](loc6: ID)
CopyLoc[3](Arg3: address)
MoveLoc[8](loc3: u128)
CopyLoc[2](Arg2: u128)
Call position::emit_position_closed_event(ID, address, u128, u128)
MoveLoc[12](loc7: &mut Position)
ReadRef
MoveLoc[4](Arg4: address)
LdConst[3](u8: 4)
MoveLoc[2](Arg2: u128)
Call position::emit_position_update_event(Position, address, u8, u128)
MoveLoc[1](Arg1: &mut Bank<Ty0>)
FreezeRef
MoveLoc[0](Arg0: &mut Perpetual)
FreezeRef
MoveLoc[3](Arg3: address)
Call option::none<address>(): Option<address>
Call sum_transaction_balance<Ty0>(&Bank<Ty0>, &Perpetual, address, Option<address>): u128
StLoc[6](loc1: u128)
MoveLoc[7](loc2: u128)
MoveLoc[6](loc1: u128)
Eq
BrFalse(117)
B10:
Branch(119)
B11:
LdU64(99989)
Abort
B12:
Ret
}
apply_funding_rate<Ty0>(Arg0: u128, Arg1: &mut Bank<Ty0>, Arg2: &mut Perpetual, Arg3: address, Arg4: u8, Arg5: u64) {
L6:	loc0: bool
L7:	loc1: S128
L8:	loc2: bool
L9:	loc3: bool
L10:	loc4: u128
L11:	loc5: FundingRate
L12:	loc6: FundingIndex
L13:	loc7: S128
L14:	loc8: address
L15:	loc9: bool
L16:	loc10: bool
L17:	loc11: FundingIndex
L18:	loc12: u128
L19:	loc13: u128
L20:	loc14: address
L21:	loc15: ID
L22:	loc16: u128
L23:	loc17: u128
L24:	loc18: u128
L25:	loc19: &mut Position
B0:
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
StLoc[21](loc15: ID)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::perp_address(&Perpetual): address
StLoc[20](loc14: address)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::insurance_active_pool(&Perpetual): address
StLoc[14](loc8: address)
CopyLoc[14](loc8: address)
CopyLoc[3](Arg3: address)
Eq
StLoc[15](loc9: bool)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::price_oracle(&Perpetual): u128
StLoc[22](loc16: u128)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::funding_rate(&Perpetual): FundingRate
StLoc[11](loc5: FundingRate)
CopyLoc[11](loc5: FundingRate)
Call funding_rate::index(FundingRate): FundingIndex
StLoc[12](loc6: FundingIndex)
MoveLoc[2](Arg2: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
CopyLoc[3](Arg3: address)
Call table::borrow_mut<address, Position>(&mut Table<address, Position>, address): &mut Position
StLoc[25](loc19: &mut Position)
CopyLoc[25](loc19: &mut Position)
FreezeRef
Call position::index(&Position): FundingIndex
StLoc[17](loc11: FundingIndex)
CopyLoc[25](loc19: &mut Position)
FreezeRef
Call position::margin(&Position): u128
StLoc[18](loc12: u128)
CopyLoc[25](loc19: &mut Position)
FreezeRef
Call position::size(&Position): u128
StLoc[24](loc18: u128)
CopyLoc[25](loc19: &mut Position)
FreezeRef
Call position::oi_open(&Position): u128
StLoc[19](loc13: u128)
CopyLoc[25](loc19: &mut Position)
FreezeRef
Call position::is_long(&Position): bool
StLoc[16](loc10: bool)
CopyLoc[25](loc19: &mut Position)
CopyLoc[12](loc6: FundingIndex)
Call position::set_index(&mut Position, FundingIndex)
CopyLoc[17](loc11: FundingIndex)
CopyLoc[12](loc6: FundingIndex)
Call funding_rate::are_indexes_equal(FundingIndex, FundingIndex): bool
BrFalse(63)
B1:
LdTrue
StLoc[6](loc0: bool)
Branch(67)
B2:
CopyLoc[24](loc18: u128)
LdU128(0)
Eq
StLoc[6](loc0: bool)
B3:
MoveLoc[6](loc0: bool)
BrFalse(74)
B4:
MoveLoc[25](loc19: &mut Position)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
Ret
B5:
CopyLoc[16](loc10: bool)
BrFalse(83)
B6:
MoveLoc[17](loc11: FundingIndex)
Call funding_rate::index_value(FundingIndex): S128
MoveLoc[12](loc6: FundingIndex)
Call funding_rate::index_value(FundingIndex): S128
Call s128::sub(S128, S128): S128
StLoc[7](loc1: S128)
Branch(89)
B7:
MoveLoc[12](loc6: FundingIndex)
Call funding_rate::index_value(FundingIndex): S128
MoveLoc[17](loc11: FundingIndex)
Call funding_rate::index_value(FundingIndex): S128
Call s128::sub(S128, S128): S128
StLoc[7](loc1: S128)
B8:
MoveLoc[7](loc1: S128)
StLoc[13](loc7: S128)
CopyLoc[13](loc7: S128)
Call s128::value(S128): u128
CopyLoc[24](loc18: u128)
Call library::base_mul(u128, u128): u128
StLoc[23](loc17: u128)
CopyLoc[13](loc7: S128)
LdU128(0)
Call s128::gt_u128(S128, u128): bool
BrFalse(118)
B9:
MoveLoc[15](loc9: bool)
BrFalse(110)
B10:
MoveLoc[1](Arg1: &mut Bank<Ty0>)
MoveLoc[20](loc14: address)
CopyLoc[3](Arg3: address)
CopyLoc[23](loc17: u128)
LdU64(2)
CopyLoc[0](Arg0: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
Branch(274)
B11:
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
CopyLoc[25](loc19: &mut Position)
MoveLoc[18](loc12: u128)
CopyLoc[23](loc17: u128)
Add
Call position::set_margin(&mut Position, u128)
Branch(274)
B12:
CopyLoc[4](Arg4: u8)
LdU8(3)
Le
BrFalse(123)
B13:
Branch(129)
B14:
MoveLoc[25](loc19: &mut Position)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(99999)
Abort
B15:
CopyLoc[13](loc7: S128)
Call s128::value(S128): u128
MoveLoc[24](loc18: u128)
Call library::base_mul_up(u128, u128): u128
StLoc[23](loc17: u128)
CopyLoc[4](Arg4: u8)
LdU8(0)
Eq
BrFalse(141)
B16:
LdTrue
StLoc[8](loc2: bool)
Branch(145)
B17:
CopyLoc[4](Arg4: u8)
LdU8(1)
Eq
StLoc[8](loc2: bool)
B18:
MoveLoc[8](loc2: bool)
BrFalse(172)
B19:
MoveLoc[15](loc9: bool)
BrFalse(159)
B20:
MoveLoc[1](Arg1: &mut Bank<Ty0>)
CopyLoc[3](Arg3: address)
MoveLoc[20](loc14: address)
MoveLoc[23](loc17: u128)
MoveLoc[5](Arg5: u64)
CopyLoc[0](Arg0: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
LdU128(0)
StLoc[23](loc17: u128)
Branch(269)
B21:
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
CopyLoc[18](loc12: u128)
CopyLoc[23](loc17: u128)
Ge
BrFalse(166)
B22:
Branch(269)
B23:
MoveLoc[25](loc19: &mut Position)
Pop
LdU64(53)
MoveLoc[5](Arg5: u64)
Add
Abort
B24:
MoveLoc[4](Arg4: u8)
LdU8(2)
Eq
BrFalse(228)
B25:
MoveLoc[5](Arg5: u64)
LdU64(1)
Eq
BrFalse(185)
B26:
CopyLoc[18](loc12: u128)
LdU128(0)
Gt
StLoc[9](loc3: bool)
Branch(187)
B27:
LdFalse
StLoc[9](loc3: bool)
B28:
MoveLoc[9](loc3: bool)
BrFalse(195)
B29:
MoveLoc[25](loc19: &mut Position)
Pop
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
LdU64(99999)
Abort
B30:
CopyLoc[18](loc12: u128)
CopyLoc[23](loc17: u128)
Lt
BrFalse(225)
B31:
CopyLoc[23](loc17: u128)
CopyLoc[18](loc12: u128)
Sub
StLoc[10](loc4: u128)
MoveLoc[1](Arg1: &mut Bank<Ty0>)
CopyLoc[14](loc8: address)
MoveLoc[20](loc14: address)
CopyLoc[10](loc4: u128)
LdU64(1)
CopyLoc[0](Arg0: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
MoveLoc[15](loc9: bool)
Not
BrFalse(220)
B32:
CopyLoc[0](Arg0: u128)
MoveLoc[21](loc15: ID)
MoveLoc[14](loc8: address)
CopyLoc[3](Arg3: address)
CopyLoc[10](loc4: u128)
Pack[0](LiquidatorPaidForAccountSettlementEvent)
Call event::emit<LiquidatorPaidForAccountSettlementEvent>(LiquidatorPaidForAccountSettlementEvent)
B33:
MoveLoc[23](loc17: u128)
MoveLoc[10](loc4: u128)
Sub
StLoc[23](loc17: u128)
Branch(269)
B34:
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
Branch(269)
B35:
MoveLoc[1](Arg1: &mut Bank<Ty0>)
Pop
CopyLoc[18](loc12: u128)
CopyLoc[23](loc17: u128)
Lt
BrFalse(269)
B36:
MoveLoc[16](loc10: bool)
BrFalse(242)
B37:
CopyLoc[25](loc19: &mut Position)
MoveLoc[19](loc13: u128)
CopyLoc[23](loc17: u128)
Add
Call position::set_oi_open(&mut Position, u128)
Branch(262)
B38:
CopyLoc[23](loc17: u128)
CopyLoc[19](loc13: u128)
Gt
BrFalse(257)
B39:
CopyLoc[25](loc19: &mut Position)
LdU128(0)
Call position::set_oi_open(&mut Position, u128)
CopyLoc[0](Arg0: u128)
CopyLoc[3](Arg3: address)
CopyLoc[23](loc17: u128)
MoveLoc[19](loc13: u128)
Sub
Pack[1](SettlementAmountNotPaidCompletelyEvent)
Call event::emit<SettlementAmountNotPaidCompletelyEvent>(SettlementAmountNotPaidCompletelyEvent)
Branch(262)
B40:
CopyLoc[25](loc19: &mut Position)
MoveLoc[19](loc13: u128)
CopyLoc[23](loc17: u128)
Sub
Call position::set_oi_open(&mut Position, u128)
B41:
CopyLoc[0](Arg0: u128)
CopyLoc[3](Arg3: address)
MoveLoc[23](loc17: u128)
Pack[2](SettlementAmtDueByMakerEvent)
Call event::emit<SettlementAmtDueByMakerEvent>(SettlementAmtDueByMakerEvent)
LdU128(0)
StLoc[23](loc17: u128)
B42:
CopyLoc[25](loc19: &mut Position)
MoveLoc[18](loc12: u128)
CopyLoc[23](loc17: u128)
Sub
Call position::set_margin(&mut Position, u128)
B43:
MoveLoc[0](Arg0: u128)
MoveLoc[3](Arg3: address)
MoveLoc[25](loc19: &mut Position)
ReadRef
MoveLoc[13](loc7: S128)
Call s128::sign(S128): bool
MoveLoc[23](loc17: u128)
MoveLoc[22](loc16: u128)
MoveLoc[11](loc5: FundingRate)
Call funding_rate::rate(FundingRate): S128
Pack[3](AccountSettlementUpdateEvent)
Call event::emit<AccountSettlementUpdateEvent>(AccountSettlementUpdateEvent)
Ret
}
public(friend) sum_transaction_balance<Ty0>(Arg0: &Bank<Ty0>, Arg1: &Perpetual, Arg2: address, Arg3: Option<address>): u128 {
L4:	loc0: bool
L5:	loc1: u128
L6:	loc2: u128
L7:	loc3: address
L8:	loc4: u128
L9:	loc5: address
L10:	loc6: u128
L11:	loc7: address
L12:	loc8: u128
B0:
CopyLoc[1](Arg1: &Perpetual)
Call perpetual::perp_address(&Perpetual): address
StLoc[9](loc5: address)
CopyLoc[0](Arg0: &Bank<Ty0>)
MoveLoc[9](loc5: address)
Call bank::get_balance<Ty0>(&Bank<Ty0>, address): u128
StLoc[10](loc6: u128)
CopyLoc[0](Arg0: &Bank<Ty0>)
CopyLoc[1](Arg1: &Perpetual)
Call perpetual::fee_pool(&Perpetual): address
Call bank::get_balance<Ty0>(&Bank<Ty0>, address): u128
StLoc[5](loc1: u128)
CopyLoc[0](Arg0: &Bank<Ty0>)
CopyLoc[1](Arg1: &Perpetual)
Call perpetual::gas_pool(&Perpetual): address
Call bank::get_balance<Ty0>(&Bank<Ty0>, address): u128
StLoc[6](loc2: u128)
MoveLoc[1](Arg1: &Perpetual)
Call perpetual::insurance_active_pool(&Perpetual): address
StLoc[7](loc3: address)
CopyLoc[0](Arg0: &Bank<Ty0>)
CopyLoc[7](loc3: address)
Call bank::get_balance<Ty0>(&Bank<Ty0>, address): u128
StLoc[8](loc4: u128)
MoveLoc[10](loc6: u128)
MoveLoc[5](loc1: u128)
Add
MoveLoc[6](loc2: u128)
Add
MoveLoc[8](loc4: u128)
Add
StLoc[12](loc8: u128)
CopyLoc[2](Arg2: address)
CopyLoc[7](loc3: address)
Neq
BrFalse(42)
B1:
MoveLoc[12](loc8: u128)
CopyLoc[0](Arg0: &Bank<Ty0>)
CopyLoc[2](Arg2: address)
Call bank::get_balance<Ty0>(&Bank<Ty0>, address): u128
Add
StLoc[12](loc8: u128)
B2:
ImmBorrowLoc[3](Arg3: Option<address>)
Call option::is_some<address>(&Option<address>): bool
BrFalse(72)
B3:
ImmBorrowLoc[3](Arg3: Option<address>)
Call option::borrow<address>(&Option<address>): &address
ReadRef
StLoc[11](loc7: address)
CopyLoc[11](loc7: address)
MoveLoc[7](loc3: address)
Neq
BrFalse(58)
B4:
CopyLoc[11](loc7: address)
MoveLoc[2](Arg2: address)
Neq
StLoc[4](loc0: bool)
Branch(60)
B5:
LdFalse
StLoc[4](loc0: bool)
B6:
MoveLoc[4](loc0: bool)
BrFalse(69)
B7:
MoveLoc[12](loc8: u128)
MoveLoc[0](Arg0: &Bank<Ty0>)
MoveLoc[11](loc7: address)
Call bank::get_balance<Ty0>(&Bank<Ty0>, address): u128
Add
StLoc[12](loc8: u128)
Branch(74)
B8:
MoveLoc[0](Arg0: &Bank<Ty0>)
Pop
Branch(74)
B9:
MoveLoc[0](Arg0: &Bank<Ty0>)
Pop
B10:
MoveLoc[12](loc8: u128)
Ret
}
Constants [
=> u8: 1
=> u8: 2
=> u8: 3
=> u8: 4
=> address: 0x0000000000000000000000000000000000000000000000000000000000000000
=> vector<u8>: "" // interpreted as UTF8 string
=> vector<u8>: "AddMargin" // interpreted as UTF8 string
=> vector<u8>: "RemoveMargin" // interpreted as UTF8 string
=> vector<u8>: "AdjustLeverage" // interpreted as UTF8 string
=> vector<u8>: "CancelOrder" // interpreted as UTF8 string
=> vector<u8>: "ClosePosition" // interpreted as UTF8 string
]
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/funding_rate.mvb361 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.funding_rate {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::s128;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
struct MaxAllowedFRUpdateEvent has copy, drop {
	id: ID,
	value: u128
}
struct GlobalIndexUpdateEvent has copy, drop {
	id: ID,
	index: FundingIndex
}
struct FundingRateUpdateEvent has copy, drop {
	id: ID,
	rate: S128,
	window: u64,
	min_application_time: u64
}
struct FundingIndex has copy, drop, store {
	value: S128,
	timestamp: u64
}
struct FundingRate has copy, drop, store {
	start_time: u64,
	max_funding: u128,
	window: u64,
	rate: S128,
	index: FundingIndex
}
public(friend) new_index(Arg0: u64): FundingIndex {
B0:
	0: Call s128::zero(): S128
	1: MoveLoc[0](Arg0: u64)
	2: Pack[3](FundingIndex)
	3: Ret
}
public(friend) initialize(Arg0: u64, Arg1: u128): FundingRate {
B0:
	0: CopyLoc[0](Arg0: u64)
	1: MoveLoc[1](Arg1: u128)
	2: LdU64(0)
	3: Call s128::zero(): S128
	4: MoveLoc[0](Arg0: u64)
	5: Call new_index(u64): FundingIndex
	6: Pack[4](FundingRate)
	7: Ret
}
public(friend) set_funding_rate(Arg0: &mut FundingRate, Arg1: u128, Arg2: bool, Arg3: u64, Arg4: ID) {
L5:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut FundingRate)
	1: ReadRef
	2: CopyLoc[3](Arg3: u64)
	3: Call expected_funding_window(FundingRate, u64): u64
	4: StLoc[5](loc0: u64)
	5: CopyLoc[5](loc0: u64)
	6: LdU64(1)
	7: Le
	8: BrFalse(12)
B1:
	9: MoveLoc[0](Arg0: &mut FundingRate)
	10: Pop
	11: Ret
B2:
	12: CopyLoc[0](Arg0: &mut FundingRate)
	13: ImmBorrowField[0](FundingRate.window: u64)
	14: ReadRef
	15: CopyLoc[5](loc0: u64)
	16: LdU64(1)
	17: Sub
	18: Lt
	19: BrFalse(21)
B3:
	20: Branch(25)
B4:
	21: MoveLoc[0](Arg0: &mut FundingRate)
	22: Pop
	23: LdU64(902)
	24: Abort
B5:
	25: CopyLoc[1](Arg1: u128)
	26: CopyLoc[0](Arg0: &mut FundingRate)
	27: ImmBorrowField[1](FundingRate.max_funding: u128)
	28: ReadRef
	29: Le
	30: BrFalse(32)
B6:
	31: Branch(36)
B7:
	32: MoveLoc[0](Arg0: &mut FundingRate)
	33: Pop
	34: LdU64(904)
	35: Abort
B8:
	36: MoveLoc[1](Arg1: u128)
	37: MoveLoc[2](Arg2: bool)
	38: Call s128::from(u128, bool): S128
	39: CopyLoc[0](Arg0: &mut FundingRate)
	40: MutBorrowField[2](FundingRate.rate: S128)
	41: WriteRef
	42: CopyLoc[5](loc0: u64)
	43: LdU64(1)
	44: Sub
	45: CopyLoc[0](Arg0: &mut FundingRate)
	46: MutBorrowField[0](FundingRate.window: u64)
	47: WriteRef
	48: MoveLoc[4](Arg4: ID)
	49: CopyLoc[0](Arg0: &mut FundingRate)
	50: ImmBorrowField[2](FundingRate.rate: S128)
	51: ReadRef
	52: CopyLoc[0](Arg0: &mut FundingRate)
	53: ImmBorrowField[0](FundingRate.window: u64)
	54: ReadRef
	55: MoveLoc[5](loc0: u64)
	56: LdConst[0](u64: 3600..)
	57: Mul
	58: MoveLoc[0](Arg0: &mut FundingRate)
	59: ImmBorrowField[3](FundingRate.start_time: u64)
	60: ReadRef
	61: Add
	62: MoveLoc[3](Arg3: u64)
	63: Sub
	64: Pack[2](FundingRateUpdateEvent)
	65: Call event::emit<FundingRateUpdateEvent>(FundingRateUpdateEvent)
	66: Ret
}
public(friend) set_max_allowed_funding_rate(Arg0: &mut FundingRate, Arg1: u128, Arg2: ID) {
B0:
	0: CopyLoc[1](Arg1: u128)
	1: Call library::base_uint(): u128
	2: Le
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut FundingRate)
	6: Pop
	7: LdU64(104)
	8: Abort
B3:
	9: CopyLoc[1](Arg1: u128)
	10: MoveLoc[0](Arg0: &mut FundingRate)
	11: MutBorrowField[1](FundingRate.max_funding: u128)
	12: WriteRef
	13: MoveLoc[2](Arg2: ID)
	14: MoveLoc[1](Arg1: u128)
	15: Pack[0](MaxAllowedFRUpdateEvent)
	16: Call event::emit<MaxAllowedFRUpdateEvent>(MaxAllowedFRUpdateEvent)
	17: Ret
}
public(friend) set_global_index(Arg0: &mut FundingRate, Arg1: FundingIndex, Arg2: ID) {
B0:
	0: CopyLoc[0](Arg0: &mut FundingRate)
	1: ImmBorrowField[4](FundingRate.index: FundingIndex)
	2: ImmBorrowField[5](FundingIndex.timestamp: u64)
	3: ReadRef
	4: ImmBorrowLoc[1](Arg1: FundingIndex)
	5: ImmBorrowField[5](FundingIndex.timestamp: u64)
	6: ReadRef
	7: Neq
	8: BrFalse(18)
B1:
	9: CopyLoc[1](Arg1: FundingIndex)
	10: MoveLoc[0](Arg0: &mut FundingRate)
	11: MutBorrowField[4](FundingRate.index: FundingIndex)
	12: WriteRef
	13: MoveLoc[2](Arg2: ID)
	14: MoveLoc[1](Arg1: FundingIndex)
	15: Pack[1](GlobalIndexUpdateEvent)
	16: Call event::emit<GlobalIndexUpdateEvent>(GlobalIndexUpdateEvent)
	17: Branch(20)
B2:
	18: MoveLoc[0](Arg0: &mut FundingRate)
	19: Pop
B3:
	20: Ret
}
public(friend) compute_new_global_index(Arg0: &Clock, Arg1: FundingRate, Arg2: u128): FundingIndex {
L3:	loc0: u128
L4:	loc1: u128
L5:	loc2: u64
L6:	loc3: S128
L7:	loc4: u128
B0:
	0: MoveLoc[0](Arg0: &Clock)
	1: Call clock::timestamp_ms(&Clock): u64
	2: StLoc[5](loc2: u64)
	3: CopyLoc[5](loc2: u64)
	4: ImmBorrowLoc[1](Arg1: FundingRate)
	5: ImmBorrowField[4](FundingRate.index: FundingIndex)
	6: ImmBorrowField[5](FundingIndex.timestamp: u64)
	7: ReadRef
	8: Gt
	9: BrFalse(19)
B1:
	10: CopyLoc[5](loc2: u64)
	11: ImmBorrowLoc[1](Arg1: FundingRate)
	12: ImmBorrowField[4](FundingRate.index: FundingIndex)
	13: ImmBorrowField[5](FundingIndex.timestamp: u64)
	14: ReadRef
	15: Sub
	16: CastU128
	17: StLoc[3](loc0: u128)
	18: Branch(21)
B2:
	19: LdU128(0)
	20: StLoc[3](loc0: u128)
B3:
	21: MoveLoc[3](loc0: u128)
	22: StLoc[7](loc4: u128)
	23: CopyLoc[7](loc4: u128)
	24: LdU128(0)
	25: Gt
	26: BrFalse(71)
B4:
	27: CopyLoc[7](loc4: u128)
	28: LdConst[0](u64: 3600..)
	29: CastU128
	30: Lt
	31: BrFalse(35)
B5:
	32: LdU128(1)
	33: StLoc[4](loc1: u128)
	34: Branch(40)
B6:
	35: MoveLoc[7](loc4: u128)
	36: LdConst[0](u64: 3600..)
	37: CastU128
	38: Div
	39: StLoc[4](loc1: u128)
B7:
	40: MoveLoc[4](loc1: u128)
	41: StLoc[7](loc4: u128)
	42: ImmBorrowLoc[1](Arg1: FundingRate)
	43: ImmBorrowField[2](FundingRate.rate: S128)
	44: ReadRef
	45: Call s128::value(S128): u128
	46: MoveLoc[7](loc4: u128)
	47: Mul
	48: MoveLoc[2](Arg2: u128)
	49: Call library::base_mul(u128, u128): u128
	50: ImmBorrowLoc[1](Arg1: FundingRate)
	51: ImmBorrowField[2](FundingRate.rate: S128)
	52: ReadRef
	53: Call s128::sign(S128): bool
	54: Call s128::from(u128, bool): S128
	55: StLoc[6](loc3: S128)
	56: ImmBorrowLoc[1](Arg1: FundingRate)
	57: ImmBorrowField[4](FundingRate.index: FundingIndex)
	58: ImmBorrowField[6](FundingIndex.value: S128)
	59: ReadRef
	60: MoveLoc[6](loc3: S128)
	61: Call s128::add(S128, S128): S128
	62: MutBorrowLoc[1](Arg1: FundingRate)
	63: MutBorrowField[4](FundingRate.index: FundingIndex)
	64: MutBorrowField[6](FundingIndex.value: S128)
	65: WriteRef
	66: MoveLoc[5](loc2: u64)
	67: MutBorrowLoc[1](Arg1: FundingRate)
	68: MutBorrowField[4](FundingRate.index: FundingIndex)
	69: MutBorrowField[5](FundingIndex.timestamp: u64)
	70: WriteRef
B8:
	71: ImmBorrowLoc[1](Arg1: FundingRate)
	72: ImmBorrowField[4](FundingRate.index: FundingIndex)
	73: ReadRef
	74: Ret
}
public(friend) index(Arg0: FundingRate): FundingIndex {
B0:
	0: ImmBorrowLoc[0](Arg0: FundingRate)
	1: ImmBorrowField[4](FundingRate.index: FundingIndex)
	2: ReadRef
	3: Ret
}
public(friend) index_value(Arg0: FundingIndex): S128 {
B0:
	0: ImmBorrowLoc[0](Arg0: FundingIndex)
	1: ImmBorrowField[6](FundingIndex.value: S128)
	2: ReadRef
	3: Ret
}
public(friend) rate(Arg0: FundingRate): S128 {
B0:
	0: ImmBorrowLoc[0](Arg0: FundingRate)
	1: ImmBorrowField[2](FundingRate.rate: S128)
	2: ReadRef
	3: Ret
}
public(friend) index_timestamp(Arg0: FundingIndex): u64 {
B0:
	0: ImmBorrowLoc[0](Arg0: FundingIndex)
	1: ImmBorrowField[5](FundingIndex.timestamp: u64)
	2: ReadRef
	3: Ret
}
public(friend) are_indexes_equal(Arg0: FundingIndex, Arg1: FundingIndex): bool {
B0:
	0: ImmBorrowLoc[0](Arg0: FundingIndex)
	1: ImmBorrowField[5](FundingIndex.timestamp: u64)
	2: ReadRef
	3: ImmBorrowLoc[1](Arg1: FundingIndex)
	4: ImmBorrowField[5](FundingIndex.timestamp: u64)
	5: ReadRef
	6: Eq
	7: Ret
}
expected_funding_window(Arg0: FundingRate, Arg1: u64): u64 {
L2:	loc0: u64
B0:
	0: CopyLoc[1](Arg1: u64)
	1: ImmBorrowLoc[0](Arg0: FundingRate)
	2: ImmBorrowField[3](FundingRate.start_time: u64)
	3: ReadRef
	4: Lt
	5: BrFalse(9)
B1:
	6: LdU64(0)
	7: StLoc[2](loc0: u64)
	8: Branch(19)
B2:
	9: MoveLoc[1](Arg1: u64)
	10: ImmBorrowLoc[0](Arg0: FundingRate)
	11: ImmBorrowField[3](FundingRate.start_time: u64)
	12: ReadRef
	13: Sub
	14: LdConst[0](u64: 3600..)
	15: Div
	16: LdU64(1)
	17: Add
	18: StLoc[2](loc0: u64)
B3:
	19: MoveLoc[2](loc0: u64)
	20: Ret
}
Constants [
	0 => u64: 3600000
]
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/insurance_fund.mvb446 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.insurance_fund {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::bank;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
struct InsuranceFund has store {
	perp_id: ID,
	active_account: address,
	security_account: address,
	transfer_interval: u64,
	transfer_amount_limit: u128,
	last_transfer_time: u64
}
struct InsuranceFundUpdateActiveAccountEvent has copy, drop {
	perp_id: ID,
	account: address
}
struct InsuranceFundUpdateSecurityAccountEvent has copy, drop {
	perp_id: ID,
	account: address
}
struct InsuranceFundUpdateTransferIntervalEvent has copy, drop {
	perp_id: ID,
	transfer_interval: u64
}
struct InsuranceFundUpdateTransferAmountLimitEvent has copy, drop {
	perp_id: ID,
	transfer_amount_limit: u128
}
struct InsuranceFundCreateEvent has copy, drop {
	perp_id: ID,
	active_account: address,
	security_account: address,
	transfer_interval: u64,
	transfer_amount_limit: u128
}
struct InsuranceFundTransferEvent has copy, drop {
	perp_id: ID,
	from_security_account: bool,
	amount: u128,
	timestamp: u64
}
public(friend) create_insurance_fund(Arg0: ID, Arg1: address, Arg2: address, Arg3: u64, Arg4: u128): InsuranceFund {
L5:	loc0: InsuranceFund
B0:
	0: CopyLoc[1](Arg1: address)
	1: LdConst[0](address: 0x00..)
	2: Neq
	3: BrFalse(5)
B1:
	4: Branch(7)
B2:
	5: LdU64(105)
	6: Abort
B3:
	7: CopyLoc[2](Arg2: address)
	8: LdConst[0](address: 0x00..)
	9: Neq
	10: BrFalse(12)
B4:
	11: Branch(14)
B5:
	12: LdU64(105)
	13: Abort
B6:
	14: CopyLoc[1](Arg1: address)
	15: CopyLoc[2](Arg2: address)
	16: Neq
	17: BrFalse(19)
B7:
	18: Branch(21)
B8:
	19: LdU64(114)
	20: Abort
B9:
	21: CopyLoc[3](Arg3: u64)
	22: LdU64(0)
	23: Gt
	24: BrFalse(26)
B10:
	25: Branch(28)
B11:
	26: LdU64(115)
	27: Abort
B12:
	28: CopyLoc[4](Arg4: u128)
	29: LdU128(0)
	30: Gt
	31: BrFalse(33)
B13:
	32: Branch(35)
B14:
	33: LdU64(117)
	34: Abort
B15:
	35: CopyLoc[0](Arg0: ID)
	36: CopyLoc[1](Arg1: address)
	37: CopyLoc[2](Arg2: address)
	38: CopyLoc[3](Arg3: u64)
	39: CopyLoc[4](Arg4: u128)
	40: LdU64(0)
	41: Pack[0](InsuranceFund)
	42: StLoc[5](loc0: InsuranceFund)
	43: MoveLoc[0](Arg0: ID)
	44: MoveLoc[1](Arg1: address)
	45: MoveLoc[2](Arg2: address)
	46: MoveLoc[3](Arg3: u64)
	47: MoveLoc[4](Arg4: u128)
	48: Pack[5](InsuranceFundCreateEvent)
	49: Call event::emit<InsuranceFundCreateEvent>(InsuranceFundCreateEvent)
	50: MoveLoc[5](loc0: InsuranceFund)
	51: Ret
}
public(friend) active_account(Arg0: &InsuranceFund): address {
B0:
	0: MoveLoc[0](Arg0: &InsuranceFund)
	1: ImmBorrowField[0](InsuranceFund.active_account: address)
	2: ReadRef
	3: Ret
}
public(friend) security_account(Arg0: &InsuranceFund): address {
B0:
	0: MoveLoc[0](Arg0: &InsuranceFund)
	1: ImmBorrowField[1](InsuranceFund.security_account: address)
	2: ReadRef
	3: Ret
}
public(friend) perp_id(Arg0: &InsuranceFund): ID {
B0:
	0: MoveLoc[0](Arg0: &InsuranceFund)
	1: ImmBorrowField[2](InsuranceFund.perp_id: ID)
	2: ReadRef
	3: Ret
}
public(friend) transfer_interval(Arg0: &InsuranceFund): u64 {
B0:
	0: MoveLoc[0](Arg0: &InsuranceFund)
	1: ImmBorrowField[3](InsuranceFund.transfer_interval: u64)
	2: ReadRef
	3: Ret
}
public(friend) last_transfer_time(Arg0: &InsuranceFund): u64 {
B0:
	0: MoveLoc[0](Arg0: &InsuranceFund)
	1: ImmBorrowField[4](InsuranceFund.last_transfer_time: u64)
	2: ReadRef
	3: Ret
}
public(friend) transfer_amount_limit(Arg0: &InsuranceFund): u128 {
B0:
	0: MoveLoc[0](Arg0: &InsuranceFund)
	1: ImmBorrowField[5](InsuranceFund.transfer_amount_limit: u128)
	2: ReadRef
	3: Ret
}
public(friend) set_active_account(Arg0: &mut InsuranceFund, Arg1: address) {
B0:
	0: CopyLoc[1](Arg1: address)
	1: LdConst[0](address: 0x00..)
	2: Neq
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut InsuranceFund)
	6: Pop
	7: LdU64(105)
	8: Abort
B3:
	9: CopyLoc[1](Arg1: address)
	10: CopyLoc[0](Arg0: &mut InsuranceFund)
	11: ImmBorrowField[1](InsuranceFund.security_account: address)
	12: ReadRef
	13: Neq
	14: BrFalse(16)
B4:
	15: Branch(20)
B5:
	16: MoveLoc[0](Arg0: &mut InsuranceFund)
	17: Pop
	18: LdU64(114)
	19: Abort
B6:
	20: CopyLoc[1](Arg1: address)
	21: CopyLoc[0](Arg0: &mut InsuranceFund)
	22: MutBorrowField[0](InsuranceFund.active_account: address)
	23: WriteRef
	24: MoveLoc[0](Arg0: &mut InsuranceFund)
	25: ImmBorrowField[2](InsuranceFund.perp_id: ID)
	26: ReadRef
	27: MoveLoc[1](Arg1: address)
	28: Pack[1](InsuranceFundUpdateActiveAccountEvent)
	29: Call event::emit<InsuranceFundUpdateActiveAccountEvent>(InsuranceFundUpdateActiveAccountEvent)
	30: Ret
}
public(friend) set_security_account(Arg0: &mut InsuranceFund, Arg1: address) {
B0:
	0: CopyLoc[1](Arg1: address)
	1: LdConst[0](address: 0x00..)
	2: Neq
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut InsuranceFund)
	6: Pop
	7: LdU64(105)
	8: Abort
B3:
	9: CopyLoc[1](Arg1: address)
	10: CopyLoc[0](Arg0: &mut InsuranceFund)
	11: ImmBorrowField[0](InsuranceFund.active_account: address)
	12: ReadRef
	13: Neq
	14: BrFalse(16)
B4:
	15: Branch(20)
B5:
	16: MoveLoc[0](Arg0: &mut InsuranceFund)
	17: Pop
	18: LdU64(114)
	19: Abort
B6:
	20: CopyLoc[1](Arg1: address)
	21: CopyLoc[0](Arg0: &mut InsuranceFund)
	22: MutBorrowField[1](InsuranceFund.security_account: address)
	23: WriteRef
	24: MoveLoc[0](Arg0: &mut InsuranceFund)
	25: ImmBorrowField[2](InsuranceFund.perp_id: ID)
	26: ReadRef
	27: MoveLoc[1](Arg1: address)
	28: Pack[2](InsuranceFundUpdateSecurityAccountEvent)
	29: Call event::emit<InsuranceFundUpdateSecurityAccountEvent>(InsuranceFundUpdateSecurityAccountEvent)
	30: Ret
}
public(friend) set_amount_limit(Arg0: &mut InsuranceFund, Arg1: u128) {
B0:
	0: CopyLoc[1](Arg1: u128)
	1: LdU128(0)
	2: Gt
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut InsuranceFund)
	6: Pop
	7: LdU64(117)
	8: Abort
B3:
	9: CopyLoc[1](Arg1: u128)
	10: CopyLoc[0](Arg0: &mut InsuranceFund)
	11: MutBorrowField[5](InsuranceFund.transfer_amount_limit: u128)
	12: WriteRef
	13: MoveLoc[0](Arg0: &mut InsuranceFund)
	14: ImmBorrowField[2](InsuranceFund.perp_id: ID)
	15: ReadRef
	16: MoveLoc[1](Arg1: u128)
	17: Pack[4](InsuranceFundUpdateTransferAmountLimitEvent)
	18: Call event::emit<InsuranceFundUpdateTransferAmountLimitEvent>(InsuranceFundUpdateTransferAmountLimitEvent)
	19: Ret
}
public(friend) set_transfer_interval(Arg0: &mut InsuranceFund, Arg1: u64) {
B0:
	0: CopyLoc[1](Arg1: u64)
	1: LdU64(0)
	2: Gt
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut InsuranceFund)
	6: Pop
	7: LdU64(115)
	8: Abort
B3:
	9: CopyLoc[1](Arg1: u64)
	10: CopyLoc[0](Arg0: &mut InsuranceFund)
	11: MutBorrowField[3](InsuranceFund.transfer_interval: u64)
	12: WriteRef
	13: MoveLoc[0](Arg0: &mut InsuranceFund)
	14: ImmBorrowField[2](InsuranceFund.perp_id: ID)
	15: ReadRef
	16: MoveLoc[1](Arg1: u64)
	17: Pack[3](InsuranceFundUpdateTransferIntervalEvent)
	18: Call event::emit<InsuranceFundUpdateTransferIntervalEvent>(InsuranceFundUpdateTransferIntervalEvent)
	19: Ret
}
public(friend) transfer_from_security_to_active<Ty0>(Arg0: &mut InsuranceFund, Arg1: &Clock, Arg2: &mut Bank<Ty0>, Arg3: u128, Arg4: u128) {
L5:	loc0: u64
B0:
	0: CopyLoc[3](Arg3: u128)
	1: LdU128(0)
	2: Gt
	3: BrFalse(5)
B1:
	4: Branch(13)
B2:
	5: MoveLoc[0](Arg0: &mut InsuranceFund)
	6: Pop
	7: MoveLoc[1](Arg1: &Clock)
	8: Pop
	9: MoveLoc[2](Arg2: &mut Bank<Ty0>)
	10: Pop
	11: LdU64(117)
	12: Abort
B3:
	13: CopyLoc[3](Arg3: u128)
	14: CopyLoc[0](Arg0: &mut InsuranceFund)
	15: ImmBorrowField[5](InsuranceFund.transfer_amount_limit: u128)
	16: ReadRef
	17: Le
	18: BrFalse(20)
B4:
	19: Branch(28)
B5:
	20: MoveLoc[0](Arg0: &mut InsuranceFund)
	21: Pop
	22: MoveLoc[1](Arg1: &Clock)
	23: Pop
	24: MoveLoc[2](Arg2: &mut Bank<Ty0>)
	25: Pop
	26: LdU64(116)
	27: Abort
B6:
	28: MoveLoc[1](Arg1: &Clock)
	29: Call clock::timestamp_ms(&Clock): u64
	30: StLoc[5](loc0: u64)
	31: CopyLoc[0](Arg0: &mut InsuranceFund)
	32: ImmBorrowField[4](InsuranceFund.last_transfer_time: u64)
	33: ReadRef
	34: LdU64(0)
	35: Gt
	36: BrFalse(54)
B7:
	37: CopyLoc[5](loc0: u64)
	38: CopyLoc[0](Arg0: &mut InsuranceFund)
	39: ImmBorrowField[4](InsuranceFund.last_transfer_time: u64)
	40: ReadRef
	41: Sub
	42: CopyLoc[0](Arg0: &mut InsuranceFund)
	43: ImmBorrowField[3](InsuranceFund.transfer_interval: u64)
	44: ReadRef
	45: Ge
	46: BrFalse(48)
B8:
	47: Branch(54)
B9:
	48: MoveLoc[0](Arg0: &mut InsuranceFund)
	49: Pop
	50: MoveLoc[2](Arg2: &mut Bank<Ty0>)
	51: Pop
	52: LdU64(115)
	53: Abort
B10:
	54: MoveLoc[2](Arg2: &mut Bank<Ty0>)
	55: CopyLoc[0](Arg0: &mut InsuranceFund)
	56: ImmBorrowField[1](InsuranceFund.security_account: address)
	57: ReadRef
	58: CopyLoc[0](Arg0: &mut InsuranceFund)
	59: ImmBorrowField[0](InsuranceFund.active_account: address)
	60: ReadRef
	61: CopyLoc[3](Arg3: u128)
	62: LdU64(0)
	63: MoveLoc[4](Arg4: u128)
	64: Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
	65: CopyLoc[5](loc0: u64)
	66: CopyLoc[0](Arg0: &mut InsuranceFund)
	67: MutBorrowField[4](InsuranceFund.last_transfer_time: u64)
	68: WriteRef
	69: MoveLoc[0](Arg0: &mut InsuranceFund)
	70: ImmBorrowField[2](InsuranceFund.perp_id: ID)
	71: ReadRef
	72: LdTrue
	73: MoveLoc[3](Arg3: u128)
	74: MoveLoc[5](loc0: u64)
	75: Pack[6](InsuranceFundTransferEvent)
	76: Call event::emit<InsuranceFundTransferEvent>(InsuranceFundTransferEvent)
	77: Ret
}
public(friend) transfer_from_active_to_security<Ty0>(Arg0: &InsuranceFund, Arg1: &Clock, Arg2: &mut Bank<Ty0>, Arg3: u128, Arg4: u128) {
B0:
	0: CopyLoc[3](Arg3: u128)
	1: LdU128(0)
	2: Gt
	3: BrFalse(5)
B1:
	4: Branch(13)
B2:
	5: MoveLoc[0](Arg0: &InsuranceFund)
	6: Pop
	7: MoveLoc[1](Arg1: &Clock)
	8: Pop
	9: MoveLoc[2](Arg2: &mut Bank<Ty0>)
	10: Pop
	11: LdU64(117)
	12: Abort
B3:
	13: MoveLoc[2](Arg2: &mut Bank<Ty0>)
	14: CopyLoc[0](Arg0: &InsuranceFund)
	15: ImmBorrowField[0](InsuranceFund.active_account: address)
	16: ReadRef
	17: CopyLoc[0](Arg0: &InsuranceFund)
	18: ImmBorrowField[1](InsuranceFund.security_account: address)
	19: ReadRef
	20: CopyLoc[3](Arg3: u128)
	21: LdU64(0)
	22: MoveLoc[4](Arg4: u128)
	23: Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
	24: MoveLoc[0](Arg0: &InsuranceFund)
	25: ImmBorrowField[2](InsuranceFund.perp_id: ID)
	26: ReadRef
	27: LdFalse
	28: MoveLoc[3](Arg3: u128)
	29: MoveLoc[1](Arg1: &Clock)
	30: Call clock::timestamp_ms(&Clock): u64
	31: Pack[6](InsuranceFundTransferEvent)
	32: Call event::emit<InsuranceFundTransferEvent>(InsuranceFundTransferEvent)
	33: Ret
}
Constants [
	0 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/isolated_trading.mvb1246 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.isolated_trading {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::evaluator;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::order;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::perpetual;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::position;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::protocol;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::s128;
use 9041eddbe15edba576c8c0bd4237e07b19e2c17fb59b240658f96522261f10c4::unified_address;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct TradeExecutedEvent has copy, drop {
	tx_index: u128,
	sender: address,
	perp_id: ID,
	trade_type: u8,
	maker: address,
	taker: address,
	make_order_hash: vector<u8>,
	taker_order_hash: vector<u8>,
	maker_mro: u128,
	taker_mro: u128,
	maker_trade_fee: u128,
	maker_gas_fee: u128,
	taker_trade_fee: u128,
	taker_gas_fee: u128,
	maker_pnl: S128,
	taker_pnl: S128,
	trade_quantity: u128,
	trade_price: u128,
	is_long: bool
}
struct TradeData has copy, drop {
	maker_signature: vector<u8>,
	taker_signature: vector<u8>,
	maker_publicKey: vector<u8>,
	taker_publicKey: vector<u8>,
	maker_order: Order,
	taker_order: Order,
	fill: Fill,
	current_time: u64
}
struct TradeDataV2 has copy, drop {
	maker_order: OrderV2,
	taker_order: OrderV2,
	maker_signatory: UnifiedAddress,
	maker_payload_version: u32,
	taker_signatory: UnifiedAddress,
	taker_payload_version: u32,
	fill: Fill,
	current_time: u64
}
struct Fill has copy, drop {
	quantity: u128,
	price: u128
}
struct IMResponse has drop {
	funds_flow: S128,
	pnl: S128,
	trade_fee: u128
}
struct TradeResponse has copy, drop, store {
	maker_funds_flow: S128,
	taker_funds_flow: S128,
	trade_fee: u128,
	gas_fee: u128
}
init(Arg0: &mut TxContext) {
B0:
MoveLoc[0](Arg0: &mut TxContext)
Call table::new<vector<u8>, OrderStatus>(&mut TxContext): Table<vector<u8>, OrderStatus>
Call transfer::public_share_object<Table<vector<u8>, OrderStatus>>(Table<vector<u8>, OrderStatus>)
Ret
}
public(friend) trade(Arg0: &ProtocolConfig, Arg1: address, Arg2: &mut Perpetual, Arg3: &mut Table<vector<u8>, OrderStatus>, Arg4: TradeDataV2, Arg5: u128): TradeResponse {
L6:	loc0: bool
L7:	loc1: u64
L8:	loc2: TradeDataV2
L9:	loc3: Fill
L10:	loc4: bool
L11:	loc5: u128
L12:	loc6: Position
L13:	loc7: Position
L14:	loc8: address
L15:	loc9: address
L16:	loc10: S128
L17:	loc11: u128
L18:	loc12: vector<u8>
L19:	loc13: u128
L20:	loc14: &mut OrderV2
L21:	loc15: IMResponse
L22:	loc16: UnifiedAddress
L23:	loc17: u128
L24:	loc18: u128
L25:	loc19: u128
L26:	loc20: Position
L27:	loc21: Position
L28:	loc22: u128
L29:	loc23: ID
L30:	loc24: &mut Table<address, Position>
L31:	loc25: address
L32:	loc26: S128
L33:	loc27: u128
L34:	loc28: vector<u8>
L35:	loc29: u128
L36:	loc30: &mut OrderV2
L37:	loc31: IMResponse
L38:	loc32: UnifiedAddress
L39:	loc33: u128
L40:	loc34: u128
L41:	loc35: TradeChecks
B0:
CopyLoc[4](Arg4: TradeDataV2)
StLoc[8](loc2: TradeDataV2)
ImmBorrowLoc[8](loc2: TradeDataV2)
ImmBorrowField[0](TradeDataV2.fill: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
Call library::base_uint(): u128
Div
MutBorrowLoc[8](loc2: TradeDataV2)
MutBorrowField[0](TradeDataV2.fill: Fill)
MutBorrowField[1](Fill.quantity: u128)
WriteRef
ImmBorrowLoc[8](loc2: TradeDataV2)
ImmBorrowField[0](TradeDataV2.fill: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
Call library::base_uint(): u128
Div
MutBorrowLoc[8](loc2: TradeDataV2)
MutBorrowField[0](TradeDataV2.fill: Fill)
MutBorrowField[2](Fill.price: u128)
WriteRef
ImmBorrowLoc[8](loc2: TradeDataV2)
ImmBorrowField[3](TradeDataV2.maker_order: OrderV2)
ReadRef
Call order::to_1x9(OrderV2): OrderV2
MutBorrowLoc[8](loc2: TradeDataV2)
MutBorrowField[3](TradeDataV2.maker_order: OrderV2)
WriteRef
ImmBorrowLoc[8](loc2: TradeDataV2)
ImmBorrowField[4](TradeDataV2.taker_order: OrderV2)
ReadRef
Call order::to_1x9(OrderV2): OrderV2
MutBorrowLoc[8](loc2: TradeDataV2)
MutBorrowField[4](TradeDataV2.taker_order: OrderV2)
WriteRef
ImmBorrowLoc[8](loc2: TradeDataV2)
ImmBorrowField[0](TradeDataV2.fill: Fill)
ReadRef
StLoc[9](loc3: Fill)
ImmBorrowLoc[8](loc2: TradeDataV2)
ImmBorrowField[5](TradeDataV2.current_time: u64)
ReadRef
StLoc[7](loc1: u64)
ImmBorrowLoc[8](loc2: TradeDataV2)
ImmBorrowField[3](TradeDataV2.maker_order: OrderV2)
Call order::creator_identifier(&OrderV2): address
StLoc[15](loc9: address)
ImmBorrowLoc[8](loc2: TradeDataV2)
ImmBorrowField[4](TradeDataV2.taker_order: OrderV2)
Call order::creator_identifier(&OrderV2): address
StLoc[31](loc25: address)
ImmBorrowLoc[8](loc2: TradeDataV2)
ImmBorrowField[6](TradeDataV2.maker_signatory: UnifiedAddress)
ReadRef
StLoc[22](loc16: UnifiedAddress)
ImmBorrowLoc[8](loc2: TradeDataV2)
ImmBorrowField[7](TradeDataV2.taker_signatory: UnifiedAddress)
ReadRef
StLoc[38](loc32: UnifiedAddress)
MutBorrowLoc[8](loc2: TradeDataV2)
MutBorrowField[3](TradeDataV2.maker_order: OrderV2)
StLoc[20](loc14: &mut OrderV2)
MutBorrowLoc[8](loc2: TradeDataV2)
MutBorrowField[4](TradeDataV2.taker_order: OrderV2)
StLoc[36](loc30: &mut OrderV2)
CopyLoc[20](loc14: &mut OrderV2)
FreezeRef
Call order::is_long(&OrderV2): bool
CopyLoc[36](loc30: &mut OrderV2)
FreezeRef
Call order::is_long(&OrderV2): bool
Neq
BrFalse(75)
B1:
Branch(87)
B2:
MoveLoc[36](loc30: &mut OrderV2)
Pop
MoveLoc[0](Arg0: &ProtocolConfig)
Pop
MoveLoc[2](Arg2: &mut Perpetual)
Pop
MoveLoc[3](Arg3: &mut Table<vector<u8>, OrderStatus>)
Pop
MoveLoc[20](loc14: &mut OrderV2)
Pop
LdU64(48)
Abort
B3:
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::price_oracle(&Perpetual): u128
StLoc[28](loc22: u128)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::checks(&Perpetual): TradeChecks
StLoc[41](loc35: TradeChecks)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
CopyLoc[15](loc9: address)
LdTrue
Call perpetual::get_fee(&Perpetual, address, bool): u128
StLoc[23](loc17: u128)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
CopyLoc[31](loc25: address)
LdFalse
Call perpetual::get_fee(&Perpetual, address, bool): u128
StLoc[39](loc33: u128)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
StLoc[29](loc23: ID)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::imr(&Perpetual): u128
StLoc[11](loc5: u128)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::mmr(&Perpetual): u128
StLoc[25](loc19: u128)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call perpetual::insurance_active_pool(&Perpetual): address
StLoc[14](loc8: address)
MoveLoc[2](Arg2: &mut Perpetual)
Call perpetual::positions(&mut Perpetual): &mut Table<address, Position>
StLoc[30](loc24: &mut Table<address, Position>)
ImmBorrowLoc[4](Arg4: TradeDataV2)
ImmBorrowField[3](TradeDataV2.maker_order: OrderV2)
ReadRef
ImmBorrowLoc[4](Arg4: TradeDataV2)
ImmBorrowField[8](TradeDataV2.maker_payload_version: u32)
ReadRef
Call order::to_json_bytes(OrderV2, u32): vector<u8>
Call library::get_hash(vector<u8>): vector<u8>
StLoc[18](loc12: vector<u8>)
ImmBorrowLoc[4](Arg4: TradeDataV2)
ImmBorrowField[4](TradeDataV2.taker_order: OrderV2)
ReadRef
ImmBorrowLoc[4](Arg4: TradeDataV2)
ImmBorrowField[9](TradeDataV2.taker_payload_version: u32)
ReadRef
Call order::to_json_bytes(OrderV2, u32): vector<u8>
Call library::get_hash(vector<u8>): vector<u8>
StLoc[34](loc28: vector<u8>)
CopyLoc[3](Arg3: &mut Table<vector<u8>, OrderStatus>)
CopyLoc[18](loc12: vector<u8>)
Call order::create_order(&mut Table<vector<u8>, OrderStatus>, vector<u8>)
CopyLoc[3](Arg3: &mut Table<vector<u8>, OrderStatus>)
CopyLoc[34](loc28: vector<u8>)
Call order::create_order(&mut Table<vector<u8>, OrderStatus>, vector<u8>)
CopyLoc[36](loc30: &mut OrderV2)
ReadRef
Call order::price(OrderV2): u128
LdU128(0)
Eq
BrFalse(165)
B4:
CopyLoc[36](loc30: &mut OrderV2)
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
Call order::set_price(&mut OrderV2, u128)
LdTrue
StLoc[6](loc0: bool)
Branch(167)
B5:
LdFalse
StLoc[6](loc0: bool)
B6:
MoveLoc[6](loc0: bool)
StLoc[10](loc4: bool)
CopyLoc[20](loc14: &mut OrderV2)
ReadRef
Call order::leverage(OrderV2): u128
Call library::round_down(u128): u128
StLoc[19](loc13: u128)
CopyLoc[20](loc14: &mut OrderV2)
MoveLoc[19](loc13: u128)
Call order::set_leverage(&mut OrderV2, u128)
CopyLoc[36](loc30: &mut OrderV2)
ReadRef
Call order::leverage(OrderV2): u128
Call library::round_down(u128): u128
StLoc[35](loc29: u128)
CopyLoc[36](loc30: &mut OrderV2)
MoveLoc[35](loc29: u128)
Call order::set_leverage(&mut OrderV2, u128)
CopyLoc[30](loc24: &mut Table<address, Position>)
FreezeRef
CopyLoc[15](loc9: address)
Call table::borrow<address, Position>(&Table<address, Position>, address): &Position
ReadRef
StLoc[12](loc6: Position)
CopyLoc[30](loc24: &mut Table<address, Position>)
FreezeRef
CopyLoc[31](loc25: address)
Call table::borrow<address, Position>(&Table<address, Position>, address): &Position
ReadRef
StLoc[13](loc7: Position)
CopyLoc[12](loc6: Position)
CopyLoc[3](Arg3: &mut Table<vector<u8>, OrderStatus>)
CopyLoc[20](loc14: &mut OrderV2)
ReadRef
CopyLoc[18](loc12: vector<u8>)
MoveLoc[22](loc16: UnifiedAddress)
CopyLoc[9](loc3: Fill)
CopyLoc[7](loc1: u64)
LdU64(0)
CopyLoc[5](Arg5: u128)
CopyLoc[14](loc8: address)
CopyLoc[15](loc9: address)
Eq
Call verify_order(Position, &mut Table<vector<u8>, OrderStatus>, OrderV2, vector<u8>, UnifiedAddress, Fill, u64, u64, u128, bool)
CopyLoc[13](loc7: Position)
CopyLoc[3](Arg3: &mut Table<vector<u8>, OrderStatus>)
CopyLoc[36](loc30: &mut OrderV2)
ReadRef
CopyLoc[34](loc28: vector<u8>)
MoveLoc[38](loc32: UnifiedAddress)
CopyLoc[9](loc3: Fill)
MoveLoc[7](loc1: u64)
LdU64(1)
CopyLoc[5](Arg5: u128)
CopyLoc[14](loc8: address)
CopyLoc[31](loc25: address)
Eq
Call verify_order(Position, &mut Table<vector<u8>, OrderStatus>, OrderV2, vector<u8>, UnifiedAddress, Fill, u64, u64, u128, bool)
CopyLoc[41](loc35: TradeChecks)
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
Call evaluator::verify_price_checks(TradeChecks, u128)
CopyLoc[41](loc35: TradeChecks)
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
MoveLoc[10](loc4: bool)
Call evaluator::verify_qty_checks(TradeChecks, u128, bool)
CopyLoc[41](loc35: TradeChecks)
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
CopyLoc[28](loc22: u128)
CopyLoc[36](loc30: &mut OrderV2)
FreezeRef
Call order::is_long(&OrderV2): bool
Call evaluator::verify_market_take_bound_checks(TradeChecks, u128, u128, bool)
CopyLoc[3](Arg3: &mut Table<vector<u8>, OrderStatus>)
FreezeRef
CopyLoc[18](loc12: vector<u8>)
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::maker_gas_fee(&ProtocolConfig): u128
Call caculate_gas_fee(&Table<vector<u8>, OrderStatus>, vector<u8>, u128, u128): u128
StLoc[17](loc11: u128)
MoveLoc[3](Arg3: &mut Table<vector<u8>, OrderStatus>)
FreezeRef
CopyLoc[34](loc28: vector<u8>)
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::taker_gas_fee(&ProtocolConfig): u128
Call caculate_gas_fee(&Table<vector<u8>, OrderStatus>, vector<u8>, u128, u128): u128
StLoc[33](loc27: u128)
CopyLoc[15](loc9: address)
CopyLoc[31](loc25: address)
Eq
BrFalse(346)
B7:
MoveLoc[0](Arg0: &ProtocolConfig)
Pop
MoveLoc[30](loc24: &mut Table<address, Position>)
Pop
MoveLoc[20](loc14: &mut OrderV2)
Pop
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
MoveLoc[23](loc17: u128)
Call library::base_mul(u128, u128): u128
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
Call library::base_mul(u128, u128): u128
StLoc[24](loc18: u128)
CopyLoc[24](loc18: u128)
LdTrue
Call s128::from(u128, bool): S128
CopyLoc[17](loc11: u128)
Call s128::add_u128(S128, u128): S128
StLoc[16](loc10: S128)
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
MoveLoc[39](loc33: u128)
Call library::base_mul(u128, u128): u128
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
Call library::base_mul(u128, u128): u128
StLoc[40](loc34: u128)
CopyLoc[40](loc34: u128)
LdTrue
Call s128::from(u128, bool): S128
CopyLoc[33](loc27: u128)
Call s128::add_u128(S128, u128): S128
StLoc[32](loc26: S128)
MoveLoc[5](Arg5: u128)
MoveLoc[1](Arg1: address)
MoveLoc[29](loc23: ID)
LdConst[0](u8: 1)
MoveLoc[15](loc9: address)
MoveLoc[31](loc25: address)
MoveLoc[18](loc12: vector<u8>)
MoveLoc[34](loc28: vector<u8>)
ImmBorrowLoc[12](loc6: Position)
Call position::mro(&Position): u128
ImmBorrowLoc[13](loc7: Position)
Call position::mro(&Position): u128
CopyLoc[24](loc18: u128)
CopyLoc[17](loc11: u128)
CopyLoc[40](loc34: u128)
CopyLoc[33](loc27: u128)
Call s128::zero(): S128
Call s128::zero(): S128
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
MoveLoc[36](loc30: &mut OrderV2)
FreezeRef
Call order::is_long(&OrderV2): bool
Pack[0](TradeExecutedEvent)
Call event::emit<TradeExecutedEvent>(TradeExecutedEvent)
MoveLoc[16](loc10: S128)
MoveLoc[32](loc26: S128)
MoveLoc[24](loc18: u128)
MoveLoc[40](loc34: u128)
Add
MoveLoc[17](loc11: u128)
MoveLoc[33](loc27: u128)
Add
Pack[5](TradeResponse)
Ret
B8:
CopyLoc[41](loc35: TradeChecks)
CopyLoc[30](loc24: &mut Table<address, Position>)
CopyLoc[15](loc9: address)
Call table::borrow_mut<address, Position>(&mut Table<address, Position>, address): &mut Position
MoveLoc[20](loc14: &mut OrderV2)
ReadRef
CopyLoc[9](loc3: Fill)
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
MoveLoc[23](loc17: u128)
Call library::base_mul_up(u128, u128): u128
LdU64(0)
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::privileged_addresses(&ProtocolConfig): &VecSet<address>
ImmBorrowLoc[15](loc9: address)
Call vec_set::contains<address>(&VecSet<address>, &address): bool
CopyLoc[14](loc8: address)
CopyLoc[15](loc9: address)
Eq
Call apply_isolated_margin(TradeChecks, &mut Position, OrderV2, Fill, u128, u64, bool, bool): IMResponse
StLoc[21](loc15: IMResponse)
MoveLoc[41](loc35: TradeChecks)
CopyLoc[30](loc24: &mut Table<address, Position>)
CopyLoc[31](loc25: address)
Call table::borrow_mut<address, Position>(&mut Table<address, Position>, address): &mut Position
CopyLoc[36](loc30: &mut OrderV2)
ReadRef
CopyLoc[9](loc3: Fill)
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
MoveLoc[39](loc33: u128)
Call library::base_mul_up(u128, u128): u128
LdU64(1)
MoveLoc[0](Arg0: &ProtocolConfig)
Call protocol::privileged_addresses(&ProtocolConfig): &VecSet<address>
ImmBorrowLoc[31](loc25: address)
Call vec_set::contains<address>(&VecSet<address>, &address): bool
CopyLoc[14](loc8: address)
CopyLoc[31](loc25: address)
Eq
Call apply_isolated_margin(TradeChecks, &mut Position, OrderV2, Fill, u128, u64, bool, bool): IMResponse
StLoc[37](loc31: IMResponse)
CopyLoc[30](loc24: &mut Table<address, Position>)
FreezeRef
CopyLoc[15](loc9: address)
Call table::borrow<address, Position>(&Table<address, Position>, address): &Position
ReadRef
StLoc[26](loc20: Position)
MoveLoc[30](loc24: &mut Table<address, Position>)
FreezeRef
CopyLoc[31](loc25: address)
Call table::borrow<address, Position>(&Table<address, Position>, address): &Position
ReadRef
StLoc[27](loc21: Position)
CopyLoc[14](loc8: address)
CopyLoc[15](loc9: address)
Neq
BrFalse(414)
B9:
ImmBorrowLoc[12](loc6: Position)
ImmBorrowLoc[26](loc20: Position)
CopyLoc[11](loc5: u128)
CopyLoc[25](loc19: u128)
CopyLoc[28](loc22: u128)
LdConst[0](u8: 1)
LdU64(0)
Call position::verify_collat_checks(&Position, &Position, u128, u128, u128, u8, u64)
B10:
MoveLoc[14](loc8: address)
CopyLoc[31](loc25: address)
Neq
BrFalse(426)
B11:
ImmBorrowLoc[13](loc7: Position)
ImmBorrowLoc[27](loc21: Position)
MoveLoc[11](loc5: u128)
MoveLoc[25](loc19: u128)
MoveLoc[28](loc22: u128)
LdConst[0](u8: 1)
LdU64(1)
Call position::verify_collat_checks(&Position, &Position, u128, u128, u128, u8, u64)
B12:
ImmBorrowLoc[21](loc15: IMResponse)
ImmBorrowField[10](IMResponse.funds_flow: S128)
ReadRef
CopyLoc[17](loc11: u128)
Call s128::add_u128(S128, u128): S128
MutBorrowLoc[21](loc15: IMResponse)
MutBorrowField[10](IMResponse.funds_flow: S128)
WriteRef
ImmBorrowLoc[37](loc31: IMResponse)
ImmBorrowField[10](IMResponse.funds_flow: S128)
ReadRef
CopyLoc[33](loc27: u128)
Call s128::add_u128(S128, u128): S128
MutBorrowLoc[37](loc31: IMResponse)
MutBorrowField[10](IMResponse.funds_flow: S128)
WriteRef
CopyLoc[26](loc20: Position)
CopyLoc[1](Arg1: address)
LdConst[1](u8: 0)
CopyLoc[5](Arg5: u128)
Call position::emit_position_update_event(Position, address, u8, u128)
CopyLoc[27](loc21: Position)
CopyLoc[1](Arg1: address)
LdConst[1](u8: 0)
CopyLoc[5](Arg5: u128)
Call position::emit_position_update_event(Position, address, u8, u128)
MoveLoc[5](Arg5: u128)
MoveLoc[1](Arg1: address)
MoveLoc[29](loc23: ID)
LdConst[0](u8: 1)
MoveLoc[15](loc9: address)
MoveLoc[31](loc25: address)
MoveLoc[18](loc12: vector<u8>)
MoveLoc[34](loc28: vector<u8>)
ImmBorrowLoc[26](loc20: Position)
Call position::mro(&Position): u128
ImmBorrowLoc[27](loc21: Position)
Call position::mro(&Position): u128
ImmBorrowLoc[21](loc15: IMResponse)
ImmBorrowField[11](IMResponse.trade_fee: u128)
ReadRef
CopyLoc[17](loc11: u128)
ImmBorrowLoc[37](loc31: IMResponse)
ImmBorrowField[11](IMResponse.trade_fee: u128)
ReadRef
CopyLoc[33](loc27: u128)
ImmBorrowLoc[21](loc15: IMResponse)
ImmBorrowField[12](IMResponse.pnl: S128)
ReadRef
ImmBorrowLoc[37](loc31: IMResponse)
ImmBorrowField[12](IMResponse.pnl: S128)
ReadRef
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
ImmBorrowLoc[9](loc3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
MoveLoc[36](loc30: &mut OrderV2)
FreezeRef
Call order::is_long(&OrderV2): bool
Pack[0](TradeExecutedEvent)
Call event::emit<TradeExecutedEvent>(TradeExecutedEvent)
ImmBorrowLoc[21](loc15: IMResponse)
ImmBorrowField[10](IMResponse.funds_flow: S128)
ReadRef
ImmBorrowLoc[37](loc31: IMResponse)
ImmBorrowField[10](IMResponse.funds_flow: S128)
ReadRef
ImmBorrowLoc[37](loc31: IMResponse)
ImmBorrowField[11](IMResponse.trade_fee: u128)
ReadRef
ImmBorrowLoc[21](loc15: IMResponse)
ImmBorrowField[11](IMResponse.trade_fee: u128)
ReadRef
Add
MoveLoc[17](loc11: u128)
MoveLoc[33](loc27: u128)
Add
Pack[5](TradeResponse)
Ret
}
public(friend) pack_trade_data(Arg0: OrderV2, Arg1: UnifiedAddress, Arg2: u32, Arg3: OrderV2, Arg4: UnifiedAddress, Arg5: u32, Arg6: u128, Arg7: u128, Arg8: u64): TradeDataV2 {
L9:	loc0: Fill
B0:
MoveLoc[6](Arg6: u128)
MoveLoc[7](Arg7: u128)
Pack[3](Fill)
StLoc[9](loc0: Fill)
MoveLoc[0](Arg0: OrderV2)
MoveLoc[3](Arg3: OrderV2)
MoveLoc[1](Arg1: UnifiedAddress)
MoveLoc[2](Arg2: u32)
MoveLoc[4](Arg4: UnifiedAddress)
MoveLoc[5](Arg5: u32)
MoveLoc[9](loc0: Fill)
MoveLoc[8](Arg8: u64)
Pack[2](TradeDataV2)
Ret
}
public(friend) maker_funds_flow(Arg0: TradeResponse): S128 {
B0:
ImmBorrowLoc[0](Arg0: TradeResponse)
ImmBorrowField[13](TradeResponse.maker_funds_flow: S128)
ReadRef
Ret
}
public(friend) taker_funds_flow(Arg0: TradeResponse): S128 {
B0:
ImmBorrowLoc[0](Arg0: TradeResponse)
ImmBorrowField[14](TradeResponse.taker_funds_flow: S128)
ReadRef
Ret
}
public(friend) trade_fee(Arg0: TradeResponse): u128 {
B0:
ImmBorrowLoc[0](Arg0: TradeResponse)
ImmBorrowField[15](TradeResponse.trade_fee: u128)
ReadRef
Ret
}
public(friend) gas_fee(Arg0: TradeResponse): u128 {
B0:
ImmBorrowLoc[0](Arg0: TradeResponse)
ImmBorrowField[16](TradeResponse.gas_fee: u128)
ReadRef
Ret
}
public(friend) trade_type(): u8 {
B0:
LdConst[0](u8: 1)
Ret
}
verify_order(Arg0: Position, Arg1: &mut Table<vector<u8>, OrderStatus>, Arg2: OrderV2, Arg3: vector<u8>, Arg4: UnifiedAddress, Arg5: Fill, Arg6: u64, Arg7: u64, Arg8: u128, Arg9: bool) {
L10:	loc0: bool
L11:	loc1: bool
B0:
CopyLoc[7](Arg7: u64)
LdU64(0)
Eq
BrFalse(7)
B1:
LdTrue
StLoc[10](loc0: bool)
Branch(11)
B2:
CopyLoc[2](Arg2: OrderV2)
Call order::post_only(OrderV2): bool
Not
StLoc[10](loc0: bool)
B3:
MoveLoc[10](loc0: bool)
BrFalse(14)
B4:
Branch(18)
B5:
MoveLoc[1](Arg1: &mut Table<vector<u8>, OrderStatus>)
Pop
LdU64(49)
Abort
B6:
CopyLoc[7](Arg7: u64)
LdU64(1)
Eq
BrFalse(25)
B7:
LdTrue
StLoc[11](loc1: bool)
Branch(29)
B8:
CopyLoc[2](Arg2: OrderV2)
Call order::ioc(OrderV2): bool
Not
StLoc[11](loc1: bool)
B9:
MoveLoc[11](loc1: bool)
BrFalse(32)
B10:
Branch(36)
B11:
MoveLoc[1](Arg1: &mut Table<vector<u8>, OrderStatus>)
Pop
LdU64(106)
Abort
B12:
CopyLoc[1](Arg1: &mut Table<vector<u8>, OrderStatus>)
FreezeRef
CopyLoc[3](Arg3: vector<u8>)
CopyLoc[7](Arg7: u64)
Call order::verify_order_state(&Table<vector<u8>, OrderStatus>, vector<u8>, u64)
CopyLoc[2](Arg2: OrderV2)
Call order::expiration(OrderV2): u64
MoveLoc[6](Arg6: u64)
CopyLoc[7](Arg7: u64)
Call order::verify_order_expiry(u64, u64, u64)
MoveLoc[9](Arg9: bool)
Not
BrFalse(55)
B13:
ImmBorrowLoc[0](Arg0: Position)
Call position::mro(&Position): u128
CopyLoc[2](Arg2: OrderV2)
Call order::leverage(OrderV2): u128
CopyLoc[7](Arg7: u64)
Call order::verify_order_leverage(u128, u128, u64)
B14:
MoveLoc[1](Arg1: &mut Table<vector<u8>, OrderStatus>)
MoveLoc[2](Arg2: OrderV2)
MoveLoc[3](Arg3: vector<u8>)
ImmBorrowLoc[5](Arg5: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
ImmBorrowLoc[5](Arg5: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
ImmBorrowLoc[0](Arg0: Position)
Call position::is_long(&Position): bool
ImmBorrowLoc[0](Arg0: Position)
Call position::size(&Position): u128
MoveLoc[4](Arg4: UnifiedAddress)
MoveLoc[7](Arg7: u64)
MoveLoc[8](Arg8: u128)
Call order::verify_and_fill_order_qty(&mut Table<vector<u8>, OrderStatus>, OrderV2, vector<u8>, u128, u128, bool, u128, UnifiedAddress, u64, u128)
Ret
}
apply_isolated_margin(Arg0: TradeChecks, Arg1: &mut Position, Arg2: OrderV2, Arg3: Fill, Arg4: u128, Arg5: u64, Arg6: bool, Arg7: bool): IMResponse {
L8:	loc0: u128
L9:	loc1: u128
L10:	loc2: bool
L11:	loc3: bool
L12:	loc4: bool
L13:	loc5: u128
L14:	loc6: u128
L15:	loc7: S128
L16:	loc8: S128
L17:	loc9: bool
L18:	loc10: bool
L19:	loc11: u128
L20:	loc12: u128
L21:	loc13: u128
L22:	loc14: u128
L23:	loc15: u128
L24:	loc16: u128
L25:	loc17: S128
L26:	loc18: u128
L27:	loc19: u128
L28:	loc20: u128
L29:	loc21: u128
B0:
ImmBorrowLoc[2](Arg2: OrderV2)
Call order::is_long(&OrderV2): bool
StLoc[17](loc9: bool)
CopyLoc[1](Arg1: &mut Position)
FreezeRef
Call position::oi_open(&Position): u128
StLoc[24](loc16: u128)
CopyLoc[1](Arg1: &mut Position)
FreezeRef
Call position::size(&Position): u128
StLoc[28](loc20: u128)
CopyLoc[1](Arg1: &mut Position)
FreezeRef
Call position::is_long(&Position): bool
StLoc[18](loc10: bool)
CopyLoc[1](Arg1: &mut Position)
FreezeRef
Call position::margin(&Position): u128
StLoc[19](loc11: u128)
CopyLoc[7](Arg7: bool)
BrFalse(24)
B1:
LdU128(0)
StLoc[8](loc0: u128)
Branch(28)
B2:
CopyLoc[2](Arg2: OrderV2)
Call order::leverage(OrderV2): u128
Call library::compute_mro(u128): u128
StLoc[8](loc0: u128)
B3:
MoveLoc[8](loc0: u128)
StLoc[21](loc13: u128)
CopyLoc[1](Arg1: &mut Position)
FreezeRef
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
Call position::compute_pnl_per_unit(&Position, u128): S128
StLoc[25](loc17: S128)
CopyLoc[28](loc20: u128)
LdU128(0)
Eq
BrFalse(44)
B4:
LdTrue
StLoc[10](loc2: bool)
Branch(48)
B5:
CopyLoc[17](loc9: bool)
CopyLoc[18](loc10: bool)
Eq
StLoc[10](loc2: bool)
B6:
MoveLoc[10](loc2: bool)
BrFalse(115)
B7:
MoveLoc[7](Arg7: bool)
Not
BrFalse(54)
B8:
Branch(58)
B9:
MoveLoc[1](Arg1: &mut Position)
Pop
LdU64(118)
Abort
B10:
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
CopyLoc[21](loc13: u128)
Call library::base_mul_up(u128, u128): u128
StLoc[20](loc12: u128)
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
CopyLoc[20](loc12: u128)
CopyLoc[4](Arg4: u128)
Add
Call library::base_mul_up(u128, u128): u128
LdTrue
Call s128::from(u128, bool): S128
StLoc[16](loc8: S128)
CopyLoc[1](Arg1: &mut Position)
MoveLoc[24](loc16: u128)
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
Call library::base_mul(u128, u128): u128
Add
Call position::set_oi_open(&mut Position, u128)
CopyLoc[1](Arg1: &mut Position)
MoveLoc[28](loc20: u128)
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
Add
Call position::set_size(&mut Position, u128)
CopyLoc[1](Arg1: &mut Position)
MoveLoc[19](loc11: u128)
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
MoveLoc[20](loc12: u128)
Call library::base_mul(u128, u128): u128
Add
Call position::set_margin(&mut Position, u128)
CopyLoc[1](Arg1: &mut Position)
MoveLoc[17](loc9: bool)
Call position::set_is_long(&mut Position, bool)
MoveLoc[0](Arg0: TradeChecks)
CopyLoc[21](loc13: u128)
CopyLoc[1](Arg1: &mut Position)
FreezeRef
Call position::oi_open(&Position): u128
MoveLoc[5](Arg5: u64)
MoveLoc[6](Arg6: bool)
Call evaluator::verify_oi_open_for_account(TradeChecks, u128, u128, u64, bool)
Call s128::zero(): S128
StLoc[25](loc17: S128)
Branch(340)
B11:
MoveLoc[2](Arg2: OrderV2)
Call order::reduce_only(OrderV2): bool
BrFalse(121)
B12:
LdTrue
StLoc[11](loc3: bool)
Branch(136)
B13:
MoveLoc[17](loc9: bool)
CopyLoc[18](loc10: bool)
Neq
BrFalse(132)
B14:
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
CopyLoc[28](loc20: u128)
Le
StLoc[12](loc4: bool)
Branch(134)
B15:
LdFalse
StLoc[12](loc4: bool)
B16:
MoveLoc[12](loc4: bool)
StLoc[11](loc3: bool)
B17:
MoveLoc[11](loc3: bool)
BrFalse(227)
B18:
CopyLoc[28](loc20: u128)
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
Sub
StLoc[22](loc14: u128)
CopyLoc[7](Arg7: bool)
Not
BrFalse(180)
B19:
CopyLoc[19](loc11: u128)
CopyLoc[28](loc20: u128)
Call library::base_div(u128, u128): u128
StLoc[20](loc12: u128)
CopyLoc[25](loc17: S128)
MoveLoc[20](loc12: u128)
Call s128::add_u128(S128, u128): S128
StLoc[15](loc7: S128)
CopyLoc[15](loc7: S128)
LdU128(0)
Call s128::gte_u128(S128, u128): bool
BrFalse(160)
B20:
Branch(166)
B21:
MoveLoc[1](Arg1: &mut Position)
Pop
MoveLoc[5](Arg5: u64)
LdU64(46)
Add
Abort
B22:
MoveLoc[15](loc7: S128)
Call s128::positive_value(S128): u128
StLoc[26](loc18: u128)
CopyLoc[4](Arg4: u128)
CopyLoc[26](loc18: u128)
Gt
BrFalse(176)
B23:
MoveLoc[26](loc18: u128)
StLoc[13](loc5: u128)
Branch(178)
B24:
MoveLoc[4](Arg4: u128)
StLoc[13](loc5: u128)
B25:
MoveLoc[13](loc5: u128)
StLoc[4](Arg4: u128)
B26:
CopyLoc[25](loc17: S128)
Call s128::negate(S128): S128
CopyLoc[4](Arg4: u128)
Call s128::add_u128(S128, u128): S128
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
Call s128::mul_u128(S128, u128): S128
CopyLoc[19](loc11: u128)
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
Mul
CopyLoc[28](loc20: u128)
Div
Call s128::sub_u128(S128, u128): S128
StLoc[16](loc8: S128)
MoveLoc[7](Arg7: bool)
Not
BrFalse(203)
B27:
MoveLoc[16](loc8: S128)
Call s128::negative_number(S128): S128
StLoc[16](loc8: S128)
B28:
MoveLoc[25](loc17: S128)
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
Call s128::mul_u128(S128, u128): S128
StLoc[25](loc17: S128)
CopyLoc[1](Arg1: &mut Position)
MoveLoc[19](loc11: u128)
CopyLoc[22](loc14: u128)
Mul
CopyLoc[28](loc20: u128)
Div
Call position::set_margin(&mut Position, u128)
CopyLoc[1](Arg1: &mut Position)
MoveLoc[24](loc16: u128)
CopyLoc[22](loc14: u128)
Mul
MoveLoc[28](loc20: u128)
Div
Call position::set_oi_open(&mut Position, u128)
CopyLoc[1](Arg1: &mut Position)
MoveLoc[22](loc14: u128)
Call position::set_size(&mut Position, u128)
Branch(340)
B29:
MoveLoc[7](Arg7: bool)
Not
BrFalse(231)
B30:
Branch(235)
B31:
MoveLoc[1](Arg1: &mut Position)
Pop
LdU64(118)
Abort
B32:
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
CopyLoc[28](loc20: u128)
Sub
StLoc[23](loc15: u128)
CopyLoc[23](loc15: u128)
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
Call library::base_mul(u128, u128): u128
StLoc[29](loc21: u128)
CopyLoc[19](loc11: u128)
CopyLoc[28](loc20: u128)
Call library::base_div(u128, u128): u128
StLoc[20](loc12: u128)
CopyLoc[25](loc17: S128)
MoveLoc[20](loc12: u128)
Call s128::add_u128(S128, u128): S128
StLoc[15](loc7: S128)
CopyLoc[15](loc7: S128)
LdU128(0)
Call s128::gte_u128(S128, u128): bool
BrFalse(260)
B33:
Branch(266)
B34:
MoveLoc[1](Arg1: &mut Position)
Pop
MoveLoc[5](Arg5: u64)
LdU64(46)
Add
Abort
B35:
MoveLoc[15](loc7: S128)
Call s128::positive_value(S128): u128
StLoc[27](loc19: u128)
CopyLoc[4](Arg4: u128)
CopyLoc[27](loc19: u128)
Gt
BrFalse(276)
B36:
MoveLoc[27](loc19: u128)
StLoc[9](loc1: u128)
Branch(278)
B37:
CopyLoc[4](Arg4: u128)
StLoc[9](loc1: u128)
B38:
MoveLoc[9](loc1: u128)
StLoc[14](loc6: u128)
CopyLoc[25](loc17: S128)
Call s128::negate(S128): S128
CopyLoc[14](loc6: u128)
Call s128::add_u128(S128, u128): S128
CopyLoc[28](loc20: u128)
Call s128::mul_u128(S128, u128): S128
MoveLoc[19](loc11: u128)
Call s128::sub_u128(S128, u128): S128
CopyLoc[23](loc15: u128)
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
CopyLoc[21](loc13: u128)
Call library::base_mul_up(u128, u128): u128
CopyLoc[4](Arg4: u128)
Add
Call library::base_mul_up(u128, u128): u128
Call s128::add_u128(S128, u128): S128
StLoc[16](loc8: S128)
CopyLoc[28](loc20: u128)
MoveLoc[14](loc6: u128)
Call library::base_mul_up(u128, u128): u128
CopyLoc[23](loc15: u128)
MoveLoc[4](Arg4: u128)
Call library::base_mul_up(u128, u128): u128
Add
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
Call library::base_div_up(u128, u128): u128
StLoc[4](Arg4: u128)
MoveLoc[25](loc17: S128)
MoveLoc[28](loc20: u128)
Call s128::mul_u128(S128, u128): S128
StLoc[25](loc17: S128)
MoveLoc[0](Arg0: TradeChecks)
CopyLoc[21](loc13: u128)
CopyLoc[29](loc21: u128)
MoveLoc[5](Arg5: u64)
MoveLoc[6](Arg6: bool)
Call evaluator::verify_oi_open_for_account(TradeChecks, u128, u128, u64, bool)
CopyLoc[1](Arg1: &mut Position)
CopyLoc[23](loc15: u128)
Call position::set_size(&mut Position, u128)
CopyLoc[1](Arg1: &mut Position)
MoveLoc[29](loc21: u128)
Call position::set_oi_open(&mut Position, u128)
CopyLoc[1](Arg1: &mut Position)
MoveLoc[23](loc15: u128)
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[2](Fill.price: u128)
ReadRef
CopyLoc[21](loc13: u128)
Call library::base_mul(u128, u128): u128
Call library::base_mul(u128, u128): u128
Call position::set_margin(&mut Position, u128)
CopyLoc[1](Arg1: &mut Position)
MoveLoc[18](loc10: bool)
Not
Call position::set_is_long(&mut Position, bool)
B39:
MoveLoc[1](Arg1: &mut Position)
MoveLoc[21](loc13: u128)
Call position::set_mro(&mut Position, u128)
MoveLoc[16](loc8: S128)
MoveLoc[25](loc17: S128)
MoveLoc[4](Arg4: u128)
ImmBorrowLoc[3](Arg3: Fill)
ImmBorrowField[1](Fill.quantity: u128)
ReadRef
Call library::base_mul_up(u128, u128): u128
Pack[4](IMResponse)
Ret
}
caculate_gas_fee(Arg0: &Table<vector<u8>, OrderStatus>, Arg1: vector<u8>, Arg2: u128, Arg3: u128): u128 {
B0:
CopyLoc[3](Arg3: u128)
LdU128(0)
Eq
BrFalse(8)
B1:
MoveLoc[0](Arg0: &Table<vector<u8>, OrderStatus>)
Pop
LdU128(0)
Ret
B2:
MoveLoc[0](Arg0: &Table<vector<u8>, OrderStatus>)
MoveLoc[1](Arg1: vector<u8>)
Call table::borrow<vector<u8>, OrderStatus>(&Table<vector<u8>, OrderStatus>, vector<u8>): &OrderStatus
Call order::get_filled_qty(&OrderStatus): u128
MoveLoc[2](Arg2: u128)
Eq
BrFalse(17)
B3:
MoveLoc[3](Arg3: u128)
Ret
B4:
LdU128(0)
Ret
}
Constants [
=> u8: 1
=> u8: 0
]
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/library.mvb238 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.library {
use 0000000000000000000000000000000000000000000000000000000000000001::hash;
struct VerificationResult has copy, drop {
	is_verified: bool,
	public_key: vector<u8>
}
public(friend) base_uint(): u128 {
B0:
	0: LdConst[0](u128: 1000..)
	1: Ret
}
public(friend) half_base_uint(): u128 {
B0:
	0: LdConst[1](u128: 5000..)
	1: Ret
}
public(friend) convert_to_usdc_base(Arg0: u128): u64 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: LdU128(1000)
	2: Div
	3: CastU64
	4: Ret
}
public(friend) base_mul(Arg0: u128, Arg1: u128): u128 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: MoveLoc[1](Arg1: u128)
	2: Mul
	3: LdConst[0](u128: 1000..)
	4: Div
	5: Ret
}
public(friend) base_mul_up(Arg0: u128, Arg1: u128): u128 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: MoveLoc[1](Arg1: u128)
	2: Mul
	3: LdConst[0](u128: 1000..)
	4: Add
	5: LdU128(1)
	6: Sub
	7: LdConst[0](u128: 1000..)
	8: Div
	9: Ret
}
public(friend) base_div(Arg0: u128, Arg1: u128): u128 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: LdConst[0](u128: 1000..)
	2: Mul
	3: MoveLoc[1](Arg1: u128)
	4: Div
	5: Ret
}
public(friend) base_div_up(Arg0: u128, Arg1: u128): u128 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: LdConst[0](u128: 1000..)
	2: Mul
	3: CopyLoc[1](Arg1: u128)
	4: Add
	5: LdU128(1)
	6: Sub
	7: MoveLoc[1](Arg1: u128)
	8: Div
	9: Ret
}
public(friend) ceil(Arg0: u128, Arg1: u128): u128 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: CopyLoc[1](Arg1: u128)
	2: Add
	3: LdU128(1)
	4: Sub
	5: CopyLoc[1](Arg1: u128)
	6: Div
	7: MoveLoc[1](Arg1: u128)
	8: Mul
	9: Ret
}
public(friend) min(Arg0: u128, Arg1: u128): u128 {
L2:	loc0: u128
B0:
	0: CopyLoc[0](Arg0: u128)
	1: CopyLoc[1](Arg1: u128)
	2: Lt
	3: BrFalse(7)
B1:
	4: MoveLoc[0](Arg0: u128)
	5: StLoc[2](loc0: u128)
	6: Branch(9)
B2:
	7: MoveLoc[1](Arg1: u128)
	8: StLoc[2](loc0: u128)
B3:
	9: MoveLoc[2](loc0: u128)
	10: Ret
}
public(friend) sub(Arg0: u128, Arg1: u128): u128 {
L2:	loc0: u128
B0:
	0: CopyLoc[0](Arg0: u128)
	1: CopyLoc[1](Arg1: u128)
	2: Gt
	3: BrFalse(9)
B1:
	4: MoveLoc[0](Arg0: u128)
	5: MoveLoc[1](Arg1: u128)
	6: Sub
	7: StLoc[2](loc0: u128)
	8: Branch(11)
B2:
	9: LdU128(0)
	10: StLoc[2](loc0: u128)
B3:
	11: MoveLoc[2](loc0: u128)
	12: Ret
}
public(friend) round_down(Arg0: u128): u128 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: Call base_uint(): u128
	2: Div
	3: Call base_uint(): u128
	4: Mul
	5: Ret
}
public(friend) round(Arg0: u128, Arg1: u128): u128 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: CopyLoc[1](Arg1: u128)
	2: LdU128(5)
	3: Mul
	4: LdU128(10)
	5: Div
	6: Add
	7: StLoc[0](Arg0: u128)
	8: CopyLoc[0](Arg0: u128)
	9: MoveLoc[0](Arg0: u128)
	10: MoveLoc[1](Arg1: u128)
	11: Mod
	12: Sub
	13: Ret
}
public(friend) compute_mro(Arg0: u128): u128 {
B0:
	0: Call base_uint(): u128
	1: MoveLoc[0](Arg0: u128)
	2: Call base_div(u128, u128): u128
	3: Ret
}
public(friend) convert_usdc_to_base_decimals(Arg0: u128): u128 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: LdU128(1000)
	2: Mul
	3: Ret
}
public(friend) decimal_1e18_to_base(Arg0: u128): u128 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: LdConst[0](u128: 1000..)
	2: Div
	3: Ret
}
public(friend) get_hash(Arg0: vector<u8>): vector<u8> {
B0:
	0: MoveLoc[0](Arg0: vector<u8>)
	1: Call hash::sha2_256(vector<u8>): vector<u8>
	2: Ret
}
public(friend) to_1x9_vec(Arg0: vector<u128>): vector<u128> {
L1:	loc0: u64
L2:	loc1: &u128
L3:	loc2: u64
L4:	loc3: vector<u128>
B0:
	0: ImmBorrowLoc[0](Arg0: vector<u128>)
	1: VecLen(1)
	2: StLoc[1](loc0: u64)
	3: VecPack(1, 0)
	4: StLoc[4](loc3: vector<u128>)
	5: LdU64(0)
	6: StLoc[3](loc2: u64)
B1:
	7: CopyLoc[3](loc2: u64)
	8: CopyLoc[1](loc0: u64)
	9: Lt
	10: BrFalse(27)
B2:
	11: Branch(12)
B3:
	12: ImmBorrowLoc[0](Arg0: vector<u128>)
	13: CopyLoc[3](loc2: u64)
	14: VecImmBorrow(1)
	15: StLoc[2](loc1: &u128)
	16: MutBorrowLoc[4](loc3: vector<u128>)
	17: MoveLoc[2](loc1: &u128)
	18: ReadRef
	19: LdConst[0](u128: 1000..)
	20: Div
	21: VecPushBack(1)
	22: MoveLoc[3](loc2: u64)
	23: LdU64(1)
	24: Add
	25: StLoc[3](loc2: u64)
	26: Branch(7)
B4:
	27: MoveLoc[4](loc3: vector<u128>)
	28: Ret
}
Constants [
	0 => u128: 1000000000
	1 => u128: 500000000
]
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/order.mvb941 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.order {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::protocol;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::sub_accounts;
use 9041eddbe15edba576c8c0bd4237e07b19e2c17fb59b240658f96522261f10c4::payload;
use 9041eddbe15edba576c8c0bd4237e07b19e2c17fb59b240658f96522261f10c4::unified_address;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
struct OrderFillEvent has copy, drop {
	tx_index: u128,
	order_hash: vector<u8>,
	order: Order,
	sig_maker: address,
	fill_price: u128,
	fill_qty: u128,
	new_filled_quantity: u128
}
struct OrderCancelEvent has copy, drop {
	tx_index: u128,
	caller: address,
	sig_maker: address,
	perpetual: address,
	order_hash: vector<u8>
}
struct OrderFlags has copy, drop {
	ioc: bool,
	post_only: bool,
	reduce_only: bool,
	is_long: bool,
	orderbook_only: bool
}
struct Order has copy, drop {
	market: address,
	creator: address,
	is_long: bool,
	reduce_only: bool,
	post_only: bool,
	orderbook_only: bool,
	ioc: bool,
	flags: u8,
	price: u128,
	quantity: u128,
	leverage: u128,
	expiration: u64,
	salt: u128
}
struct OrderV2 has copy, drop {
	market: address,
	creator: UnifiedAddress,
	is_long: bool,
	reduce_only: bool,
	post_only: bool,
	orderbook_only: bool,
	ioc: bool,
	flags: u8,
	price: u128,
	quantity: u128,
	leverage: u128,
	expiration: u64,
	salt: u128
}
struct OrderStatus has store {
	status: bool,
	filled_qty: u128
}
entry cancel_order(Arg0: &ProtocolConfig, Arg1: &SubAccounts, Arg2: &mut TxIndexer, Arg3: &mut Table<vector<u8>, OrderStatus>, Arg4: address, Arg5: u8, Arg6: u128, Arg7: u128, Arg8: u128, Arg9: u64, Arg10: u128, Arg11: address, Arg12: vector<u8>, Arg13: vector<u8>, Arg14: vector<u8>, Arg15: &TxContext) {
B0:
LdU64(999)
Abort
}
entry cancel_order_v2(Arg0: &ProtocolConfig, Arg1: &SubAccounts, Arg2: &mut TxIndexer, Arg3: &mut Table<vector<u8>, OrderStatus>, Arg4: address, Arg5: u8, Arg6: u128, Arg7: u128, Arg8: u128, Arg9: u64, Arg10: u128, Arg11: address, Arg12: &TxContext) {
B0:
LdU64(999)
Abort
}
public(friend) cancel(Arg0: &mut Table<vector<u8>, OrderStatus>, Arg1: vector<u8>, Arg2: address, Arg3: address, Arg4: u128) {
L5:	loc0: address
L6:	loc1: address
L7:	loc2: vector<u8>
L8:	loc3: address
L9:	loc4: &mut OrderStatus
B0:
CopyLoc[0](Arg0: &mut Table<vector<u8>, OrderStatus>)
CopyLoc[1](Arg1: vector<u8>)
Call create_order(&mut Table<vector<u8>, OrderStatus>, vector<u8>)
MoveLoc[0](Arg0: &mut Table<vector<u8>, OrderStatus>)
CopyLoc[1](Arg1: vector<u8>)
Call table::borrow_mut<vector<u8>, OrderStatus>(&mut Table<vector<u8>, OrderStatus>, vector<u8>): &mut OrderStatus
StLoc[9](loc4: &mut OrderStatus)
CopyLoc[9](loc4: &mut OrderStatus)
ImmBorrowField[0](OrderStatus.status: bool)
ReadRef
BrFalse(12)
B1:
Branch(16)
B2:
MoveLoc[9](loc4: &mut OrderStatus)
Pop
LdU64(28)
Abort
B3:
LdFalse
MoveLoc[9](loc4: &mut OrderStatus)
MutBorrowField[0](OrderStatus.status: bool)
WriteRef
CopyLoc[3](Arg3: address)
StLoc[5](loc0: address)
MoveLoc[3](Arg3: address)
StLoc[6](loc1: address)
MoveLoc[1](Arg1: vector<u8>)
StLoc[7](loc2: vector<u8>)
MoveLoc[2](Arg2: address)
StLoc[8](loc3: address)
MoveLoc[4](Arg4: u128)
MoveLoc[5](loc0: address)
MoveLoc[6](loc1: address)
MoveLoc[8](loc3: address)
MoveLoc[7](loc2: vector<u8>)
Pack[1](OrderCancelEvent)
Call event::emit<OrderCancelEvent>(OrderCancelEvent)
Ret
}
public(friend) flag_orderbook_only(Arg0: u8): bool {
B0:
MoveLoc[0](Arg0: u8)
LdU8(16)
BitAnd
LdU8(0)
Gt
Ret
}
public(friend) is_long(Arg0: &OrderV2): bool {
B0:
MoveLoc[0](Arg0: &OrderV2)
ImmBorrowField[1](OrderV2.is_long: bool)
ReadRef
Ret
}
public(friend) creator(Arg0: OrderV2): UnifiedAddress {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[2](OrderV2.creator: UnifiedAddress)
ReadRef
Ret
}
public(friend) creator_identifier(Arg0: &OrderV2): address {
B0:
MoveLoc[0](Arg0: &OrderV2)
ImmBorrowField[2](OrderV2.creator: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
Ret
}
public(friend) to_json_bytes(Arg0: OrderV2, Arg1: u32): vector<u8> {
L2:	loc0: JsonBuilder
B0:
Call payload::new_builder(): JsonBuilder
StLoc[2](loc0: JsonBuilder)
CopyLoc[1](Arg1: u32)
LdU32(2)
Eq
BrFalse(10)
B1:
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[0](vector<u8>: "act..)
LdConst[1](vector<u8>: "Pla..)
Call payload::add_bytes(&mut JsonBuilder, vector<u8>, vector<u8>)
B2:
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[2](vector<u8>: "mar..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[3](OrderV2.market: address)
ReadRef
Call payload::add_address(&mut JsonBuilder, vector<u8>, address)
CopyLoc[1](Arg1: u32)
LdU32(1)
Eq
BrFalse(34)
B3:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[2](OrderV2.creator: UnifiedAddress)
Call unified_address::is_sui(&UnifiedAddress): bool
BrFalse(25)
B4:
Branch(27)
B5:
LdU64(2100)
Abort
B6:
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[3](vector<u8>: "cre..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[2](OrderV2.creator: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
Call payload::add_address(&mut JsonBuilder, vector<u8>, address)
Branch(47)
B7:
MoveLoc[1](Arg1: u32)
LdU32(2)
Eq
BrFalse(39)
B8:
Branch(41)
B9:
LdU64(2101)
Abort
B10:
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[3](vector<u8>: "cre..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[2](OrderV2.creator: UnifiedAddress)
Call unified_address::display_bytes(&UnifiedAddress): vector<u8>
Call payload::add_bytes(&mut JsonBuilder, vector<u8>, vector<u8>)
B11:
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[4](vector<u8>: "isL..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[1](OrderV2.is_long: bool)
ReadRef
Call payload::add_bool(&mut JsonBuilder, vector<u8>, bool)
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[5](vector<u8>: "red..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[4](OrderV2.reduce_only: bool)
ReadRef
Call payload::add_bool(&mut JsonBuilder, vector<u8>, bool)
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[6](vector<u8>: "pos..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[5](OrderV2.post_only: bool)
ReadRef
Call payload::add_bool(&mut JsonBuilder, vector<u8>, bool)
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[7](vector<u8>: "ord..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[6](OrderV2.orderbook_only: bool)
ReadRef
Call payload::add_bool(&mut JsonBuilder, vector<u8>, bool)
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[8](vector<u8>: "ioc..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[7](OrderV2.ioc: bool)
ReadRef
Call payload::add_bool(&mut JsonBuilder, vector<u8>, bool)
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[9](vector<u8>: "qua..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[8](OrderV2.quantity: u128)
ReadRef
Call payload::add_u128(&mut JsonBuilder, vector<u8>, u128)
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[10](vector<u8>: "pri..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[9](OrderV2.price: u128)
ReadRef
Call payload::add_u128(&mut JsonBuilder, vector<u8>, u128)
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[11](vector<u8>: "lev..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[10](OrderV2.leverage: u128)
ReadRef
Call payload::add_u128(&mut JsonBuilder, vector<u8>, u128)
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[12](vector<u8>: "exp..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[11](OrderV2.expiration: u64)
ReadRef
Call payload::add_u64(&mut JsonBuilder, vector<u8>, u64)
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[13](vector<u8>: "sal..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[12](OrderV2.salt: u128)
ReadRef
Call payload::add_u128(&mut JsonBuilder, vector<u8>, u128)
MutBorrowLoc[2](loc0: JsonBuilder)
LdConst[14](vector<u8>: "ord..)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[13](OrderV2.flags: u8)
ReadRef
Call payload::add_u8(&mut JsonBuilder, vector<u8>, u8)
MoveLoc[2](loc0: JsonBuilder)
Call payload::build(JsonBuilder): vector<u8>
Ret
}
public(friend) market(Arg0: OrderV2): address {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[3](OrderV2.market: address)
ReadRef
Ret
}
public(friend) reduce_only(Arg0: OrderV2): bool {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[4](OrderV2.reduce_only: bool)
ReadRef
Ret
}
public(friend) post_only(Arg0: OrderV2): bool {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[5](OrderV2.post_only: bool)
ReadRef
Ret
}
public(friend) orderbook_only(Arg0: OrderV2): bool {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[6](OrderV2.orderbook_only: bool)
ReadRef
Ret
}
public(friend) ioc(Arg0: OrderV2): bool {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[7](OrderV2.ioc: bool)
ReadRef
Ret
}
public(friend) flags(Arg0: OrderV2): u8 {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[13](OrderV2.flags: u8)
ReadRef
Ret
}
public(friend) price(Arg0: OrderV2): u128 {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[9](OrderV2.price: u128)
ReadRef
Ret
}
public(friend) quantity(Arg0: OrderV2): u128 {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[8](OrderV2.quantity: u128)
ReadRef
Ret
}
public(friend) leverage(Arg0: OrderV2): u128 {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[10](OrderV2.leverage: u128)
ReadRef
Ret
}
public(friend) expiration(Arg0: OrderV2): u64 {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[11](OrderV2.expiration: u64)
ReadRef
Ret
}
public(friend) salt(Arg0: OrderV2): u128 {
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[12](OrderV2.salt: u128)
ReadRef
Ret
}
public(friend) pack_order(Arg0: address, Arg1: u8, Arg2: u128, Arg3: u128, Arg4: u128, Arg5: UnifiedAddress, Arg6: u64, Arg7: u128): OrderV2 {
L8:	loc0: address
L9:	loc1: u128
L10:	loc2: u128
L11:	loc3: u64
L12:	loc4: u128
L13:	loc5: UnifiedAddress
L14:	loc6: bool
L15:	loc7: bool
L16:	loc8: bool
L17:	loc9: bool
L18:	loc10: bool
L19:	loc11: u8
L20:	loc12: u128
L21:	loc13: OrderFlags
B0:
CopyLoc[1](Arg1: u8)
Call decode_order_flags(u8): OrderFlags
StLoc[21](loc13: OrderFlags)
MoveLoc[0](Arg0: address)
StLoc[8](loc0: address)
MoveLoc[5](Arg5: UnifiedAddress)
StLoc[13](loc5: UnifiedAddress)
ImmBorrowLoc[21](loc13: OrderFlags)
ImmBorrowField[14](OrderFlags.is_long: bool)
ReadRef
StLoc[14](loc6: bool)
ImmBorrowLoc[21](loc13: OrderFlags)
ImmBorrowField[15](OrderFlags.post_only: bool)
ReadRef
StLoc[15](loc7: bool)
ImmBorrowLoc[21](loc13: OrderFlags)
ImmBorrowField[16](OrderFlags.orderbook_only: bool)
ReadRef
StLoc[16](loc8: bool)
ImmBorrowLoc[21](loc13: OrderFlags)
ImmBorrowField[17](OrderFlags.reduce_only: bool)
ReadRef
StLoc[17](loc9: bool)
ImmBorrowLoc[21](loc13: OrderFlags)
ImmBorrowField[18](OrderFlags.ioc: bool)
ReadRef
StLoc[18](loc10: bool)
MoveLoc[1](Arg1: u8)
StLoc[19](loc11: u8)
MoveLoc[2](Arg2: u128)
StLoc[20](loc12: u128)
MoveLoc[3](Arg3: u128)
StLoc[9](loc1: u128)
MoveLoc[4](Arg4: u128)
StLoc[10](loc2: u128)
MoveLoc[6](Arg6: u64)
StLoc[11](loc3: u64)
MoveLoc[7](Arg7: u128)
StLoc[12](loc4: u128)
MoveLoc[8](loc0: address)
MoveLoc[13](loc5: UnifiedAddress)
MoveLoc[14](loc6: bool)
MoveLoc[17](loc9: bool)
MoveLoc[15](loc7: bool)
MoveLoc[16](loc8: bool)
MoveLoc[18](loc10: bool)
MoveLoc[19](loc11: u8)
MoveLoc[20](loc12: u128)
MoveLoc[9](loc1: u128)
MoveLoc[10](loc2: u128)
MoveLoc[11](loc3: u64)
MoveLoc[12](loc4: u128)
Pack[4](OrderV2)
Ret
}
public(friend) order_v2_to_order(Arg0: OrderV2): Order {
L1:	loc0: address
L2:	loc1: u128
L3:	loc2: u128
L4:	loc3: u64
L5:	loc4: u128
L6:	loc5: address
L7:	loc6: bool
L8:	loc7: bool
L9:	loc8: bool
L10:	loc9: bool
L11:	loc10: bool
L12:	loc11: u8
L13:	loc12: u128
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[3](OrderV2.market: address)
ReadRef
StLoc[1](loc0: address)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[2](OrderV2.creator: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
StLoc[6](loc5: address)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[1](OrderV2.is_long: bool)
ReadRef
StLoc[7](loc6: bool)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[5](OrderV2.post_only: bool)
ReadRef
StLoc[8](loc7: bool)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[6](OrderV2.orderbook_only: bool)
ReadRef
StLoc[9](loc8: bool)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[4](OrderV2.reduce_only: bool)
ReadRef
StLoc[10](loc9: bool)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[7](OrderV2.ioc: bool)
ReadRef
StLoc[11](loc10: bool)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[13](OrderV2.flags: u8)
ReadRef
StLoc[12](loc11: u8)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[9](OrderV2.price: u128)
ReadRef
StLoc[13](loc12: u128)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[8](OrderV2.quantity: u128)
ReadRef
StLoc[2](loc1: u128)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[10](OrderV2.leverage: u128)
ReadRef
StLoc[3](loc2: u128)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[11](OrderV2.expiration: u64)
ReadRef
StLoc[4](loc3: u64)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[12](OrderV2.salt: u128)
ReadRef
StLoc[5](loc4: u128)
MoveLoc[1](loc0: address)
MoveLoc[6](loc5: address)
MoveLoc[7](loc6: bool)
MoveLoc[10](loc9: bool)
MoveLoc[8](loc7: bool)
MoveLoc[9](loc8: bool)
MoveLoc[11](loc10: bool)
MoveLoc[12](loc11: u8)
MoveLoc[13](loc12: u128)
MoveLoc[2](loc1: u128)
MoveLoc[3](loc2: u128)
MoveLoc[4](loc3: u64)
MoveLoc[5](loc4: u128)
Pack[3](Order)
Ret
}
public(friend) to_1x9(Arg0: OrderV2): OrderV2 {
L1:	loc0: address
L2:	loc1: u128
L3:	loc2: u128
L4:	loc3: u64
L5:	loc4: u128
L6:	loc5: UnifiedAddress
L7:	loc6: bool
L8:	loc7: bool
L9:	loc8: bool
L10:	loc9: bool
L11:	loc10: bool
L12:	loc11: u8
L13:	loc12: u128
B0:
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[3](OrderV2.market: address)
ReadRef
StLoc[1](loc0: address)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[2](OrderV2.creator: UnifiedAddress)
ReadRef
StLoc[6](loc5: UnifiedAddress)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[1](OrderV2.is_long: bool)
ReadRef
StLoc[7](loc6: bool)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[5](OrderV2.post_only: bool)
ReadRef
StLoc[8](loc7: bool)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[6](OrderV2.orderbook_only: bool)
ReadRef
StLoc[9](loc8: bool)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[4](OrderV2.reduce_only: bool)
ReadRef
StLoc[10](loc9: bool)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[7](OrderV2.ioc: bool)
ReadRef
StLoc[11](loc10: bool)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[13](OrderV2.flags: u8)
ReadRef
StLoc[12](loc11: u8)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[9](OrderV2.price: u128)
ReadRef
Call library::base_uint(): u128
Div
StLoc[13](loc12: u128)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[8](OrderV2.quantity: u128)
ReadRef
Call library::base_uint(): u128
Div
StLoc[2](loc1: u128)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[10](OrderV2.leverage: u128)
ReadRef
Call library::base_uint(): u128
Div
StLoc[3](loc2: u128)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[11](OrderV2.expiration: u64)
ReadRef
StLoc[4](loc3: u64)
ImmBorrowLoc[0](Arg0: OrderV2)
ImmBorrowField[12](OrderV2.salt: u128)
ReadRef
StLoc[5](loc4: u128)
MoveLoc[1](loc0: address)
MoveLoc[6](loc5: UnifiedAddress)
MoveLoc[7](loc6: bool)
MoveLoc[10](loc9: bool)
MoveLoc[8](loc7: bool)
MoveLoc[9](loc8: bool)
MoveLoc[11](loc10: bool)
MoveLoc[12](loc11: u8)
MoveLoc[13](loc12: u128)
MoveLoc[2](loc1: u128)
MoveLoc[3](loc2: u128)
MoveLoc[4](loc3: u64)
MoveLoc[5](loc4: u128)
Pack[4](OrderV2)
Ret
}
public(friend) set_price(Arg0: &mut OrderV2, Arg1: u128) {
B0:
MoveLoc[1](Arg1: u128)
MoveLoc[0](Arg0: &mut OrderV2)
MutBorrowField[9](OrderV2.price: u128)
WriteRef
Ret
}
public(friend) set_leverage(Arg0: &mut OrderV2, Arg1: u128) {
B0:
MoveLoc[1](Arg1: u128)
MoveLoc[0](Arg0: &mut OrderV2)
MutBorrowField[10](OrderV2.leverage: u128)
WriteRef
Ret
}
public(friend) create_order(Arg0: &mut Table<vector<u8>, OrderStatus>, Arg1: vector<u8>) {
B0:
CopyLoc[0](Arg0: &mut Table<vector<u8>, OrderStatus>)
FreezeRef
CopyLoc[1](Arg1: vector<u8>)
Call table::contains<vector<u8>, OrderStatus>(&Table<vector<u8>, OrderStatus>, vector<u8>): bool
Not
BrFalse(13)
B1:
MoveLoc[0](Arg0: &mut Table<vector<u8>, OrderStatus>)
MoveLoc[1](Arg1: vector<u8>)
LdTrue
LdU128(0)
Pack[5](OrderStatus)
Call table::add<vector<u8>, OrderStatus>(&mut Table<vector<u8>, OrderStatus>, vector<u8>, OrderStatus)
Branch(15)
B2:
MoveLoc[0](Arg0: &mut Table<vector<u8>, OrderStatus>)
Pop
B3:
Ret
}
public(friend) verify_order_state(Arg0: &Table<vector<u8>, OrderStatus>, Arg1: vector<u8>, Arg2: u64) {
B0:
MoveLoc[0](Arg0: &Table<vector<u8>, OrderStatus>)
MoveLoc[1](Arg1: vector<u8>)
Call table::borrow<vector<u8>, OrderStatus>(&Table<vector<u8>, OrderStatus>, vector<u8>): &OrderStatus
ImmBorrowField[0](OrderStatus.status: bool)
ReadRef
BrFalse(7)
B1:
Branch(11)
B2:
MoveLoc[2](Arg2: u64)
LdU64(28)
Add
Abort
B3:
Ret
}
public(friend) verify_and_fill_order_qty(Arg0: &mut Table<vector<u8>, OrderStatus>, Arg1: OrderV2, Arg2: vector<u8>, Arg3: u128, Arg4: u128, Arg5: bool, Arg6: u128, Arg7: UnifiedAddress, Arg8: u64, Arg9: u128) {
L10:	loc0: bool
L11:	loc1: bool
L12:	loc2: &mut OrderStatus
B0:
ImmBorrowLoc[1](Arg1: OrderV2)
ImmBorrowField[1](OrderV2.is_long: bool)
ReadRef
BrFalse(11)
B1:
CopyLoc[3](Arg3: u128)
ImmBorrowLoc[1](Arg1: OrderV2)
ImmBorrowField[9](OrderV2.price: u128)
ReadRef
Le
StLoc[10](loc0: bool)
Branch(17)
B2:
CopyLoc[3](Arg3: u128)
ImmBorrowLoc[1](Arg1: OrderV2)
ImmBorrowField[9](OrderV2.price: u128)
ReadRef
Ge
StLoc[10](loc0: bool)
B3:
MoveLoc[10](loc0: bool)
BrFalse(20)
B4:
Branch(26)
B5:
MoveLoc[0](Arg0: &mut Table<vector<u8>, OrderStatus>)
Pop
MoveLoc[8](Arg8: u64)
LdU64(34)
Add
Abort
B6:
ImmBorrowLoc[1](Arg1: OrderV2)
ImmBorrowField[4](OrderV2.reduce_only: bool)
ReadRef
BrFalse(52)
B7:
ImmBorrowLoc[1](Arg1: OrderV2)
ImmBorrowField[1](OrderV2.is_long: bool)
ReadRef
MoveLoc[5](Arg5: bool)
Neq
BrFalse(41)
B8:
CopyLoc[4](Arg4: u128)
MoveLoc[6](Arg6: u128)
Le
StLoc[11](loc1: bool)
Branch(43)
B9:
LdFalse
StLoc[11](loc1: bool)
B10:
MoveLoc[11](loc1: bool)
BrFalse(46)
B11:
Branch(52)
B12:
MoveLoc[0](Arg0: &mut Table<vector<u8>, OrderStatus>)
Pop
MoveLoc[8](Arg8: u64)
LdU64(38)
Add
Abort
B13:
MoveLoc[0](Arg0: &mut Table<vector<u8>, OrderStatus>)
CopyLoc[2](Arg2: vector<u8>)
Call table::borrow_mut<vector<u8>, OrderStatus>(&mut Table<vector<u8>, OrderStatus>, vector<u8>): &mut OrderStatus
StLoc[12](loc2: &mut OrderStatus)
CopyLoc[12](loc2: &mut OrderStatus)
ImmBorrowField[19](OrderStatus.filled_qty: u128)
ReadRef
CopyLoc[4](Arg4: u128)
Add
CopyLoc[12](loc2: &mut OrderStatus)
MutBorrowField[19](OrderStatus.filled_qty: u128)
WriteRef
CopyLoc[12](loc2: &mut OrderStatus)
ImmBorrowField[19](OrderStatus.filled_qty: u128)
ReadRef
ImmBorrowLoc[1](Arg1: OrderV2)
ImmBorrowField[8](OrderV2.quantity: u128)
ReadRef
Le
BrFalse(73)
B14:
Branch(79)
B15:
MoveLoc[12](loc2: &mut OrderStatus)
Pop
MoveLoc[8](Arg8: u64)
LdU64(44)
Add
Abort
B16:
MoveLoc[9](Arg9: u128)
MoveLoc[2](Arg2: vector<u8>)
MoveLoc[1](Arg1: OrderV2)
Call order_v2_to_order(OrderV2): Order
ImmBorrowLoc[7](Arg7: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
MoveLoc[3](Arg3: u128)
MoveLoc[4](Arg4: u128)
MoveLoc[12](loc2: &mut OrderStatus)
ImmBorrowField[19](OrderStatus.filled_qty: u128)
ReadRef
Pack[0](OrderFillEvent)
Call event::emit<OrderFillEvent>(OrderFillEvent)
Ret
}
public(friend) verify_order_expiry(Arg0: u64, Arg1: u64, Arg2: u64) {
L3:	loc0: bool
B0:
CopyLoc[0](Arg0: u64)
LdU64(0)
Eq
BrFalse(7)
B1:
LdTrue
StLoc[3](loc0: bool)
Branch(11)
B2:
MoveLoc[0](Arg0: u64)
MoveLoc[1](Arg1: u64)
Gt
StLoc[3](loc0: bool)
B3:
MoveLoc[3](loc0: bool)
BrFalse(14)
B4:
Branch(18)
B5:
MoveLoc[2](Arg2: u64)
LdU64(32)
Add
Abort
B6:
Ret
}
public(friend) verify_order_leverage(Arg0: u128, Arg1: u128, Arg2: u64) {
L3:	loc0: bool
B0:
CopyLoc[1](Arg1: u128)
LdU128(0)
Gt
BrFalse(5)
B1:
Branch(9)
B2:
MoveLoc[2](Arg2: u64)
LdU64(42)
Add
Abort
B3:
CopyLoc[0](Arg0: u128)
LdU128(0)
Eq
BrFalse(16)
B4:
LdTrue
StLoc[3](loc0: bool)
Branch(21)
B5:
MoveLoc[1](Arg1: u128)
Call library::compute_mro(u128): u128
MoveLoc[0](Arg0: u128)
Eq
StLoc[3](loc0: bool)
B6:
MoveLoc[3](loc0: bool)
BrFalse(24)
B7:
Branch(28)
B8:
MoveLoc[2](Arg2: u64)
LdU64(40)
Add
Abort
B9:
Ret
}
public(friend) get_filled_qty(Arg0: &OrderStatus): u128 {
B0:
MoveLoc[0](Arg0: &OrderStatus)
ImmBorrowField[19](OrderStatus.filled_qty: u128)
ReadRef
Ret
}
decode_order_flags(Arg0: u8): OrderFlags {
B0:
CopyLoc[0](Arg0: u8)
LdU8(1)
BitAnd
LdU8(0)
Gt
CopyLoc[0](Arg0: u8)
LdU8(2)
BitAnd
LdU8(0)
Gt
CopyLoc[0](Arg0: u8)
LdU8(4)
BitAnd
LdU8(0)
Gt
CopyLoc[0](Arg0: u8)
LdU8(8)
BitAnd
LdU8(0)
Gt
MoveLoc[0](Arg0: u8)
LdU8(16)
BitAnd
LdU8(0)
Gt
Pack[2](OrderFlags)
Ret
}
Constants [
=> vector<u8>: "action" // interpreted as UTF8 string
=> vector<u8>: "PlaceOrder" // interpreted as UTF8 string
=> vector<u8>: "market" // interpreted as UTF8 string
=> vector<u8>: "creator" // interpreted as UTF8 string
=> vector<u8>: "isLong" // interpreted as UTF8 string
=> vector<u8>: "reduceOnly" // interpreted as UTF8 string
=> vector<u8>: "postOnly" // interpreted as UTF8 string
=> vector<u8>: "orderbookOnly" // interpreted as UTF8 string
=> vector<u8>: "ioc" // interpreted as UTF8 string
=> vector<u8>: "quantity" // interpreted as UTF8 string
=> vector<u8>: "price" // interpreted as UTF8 string
=> vector<u8>: "leverage" // interpreted as UTF8 string
=> vector<u8>: "expiration" // interpreted as UTF8 string
=> vector<u8>: "salt" // interpreted as UTF8 string
=> vector<u8>: "orderFlag" // interpreted as UTF8 string
]
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/perpetual.mvb1429 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.perpetual {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::bank;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::evaluator;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::funding_rate;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::insurance_fund;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::position;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::price_feed;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::protocol;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::roles;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::sub_accounts;
use 8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e::price_info;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
struct PerpetualCreationEvent has copy, drop {
	id: ID,
	name: String,
	imr: u128,
	mmr: u128,
	maker_fee: u128,
	taker_fee: u128,
	fee_pool: address,
	gas_pool: address,
	start_time: u64,
	price_identifier_id: vector<u8>,
	checks: TradeChecks,
	funding: FundingRate
}
struct FeePoolAccountUpdateEvent has copy, drop {
	id: ID,
	account: address
}
struct GasPoolAccountUpdateEvent has copy, drop {
	id: ID,
	account: address
}
struct DelistEvent has copy, drop {
	id: ID,
	delisting_price: u128
}
struct TradingPermissionStatusUpdateEvent has copy, drop {
	status: bool
}
struct MMRUpdateEvent has copy, drop {
	id: ID,
	mmr: u128
}
struct IMRUpdateEvent has copy, drop {
	id: ID,
	imr: u128
}
struct SpecialFeeEvent has copy, drop {
	perp: ID,
	account: address,
	status: bool,
	maker_fee: u128,
	taker_fee: u128
}
struct PriceOracleIdentifierUpdateEvent has copy, drop {
	perp: ID,
	identifier: vector<u8>
}
struct MakerFeeUpdateEvent has copy, drop {
	perp: ID,
	maker_fee: u128
}
struct TakerFeeUpdateEvent has copy, drop {
	perp: ID,
	taker_fee: u128
}
struct Perpetual has key {
	id: UID,
	name: String,
	imr: u128,
	mmr: u128,
	maker_fee: u128,
	taker_fee: u128,
	insurance_fund: InsuranceFund,
	fee_pool: address,
	gas_pool: address,
	delisted: bool,
	delisting_price: u128,
	is_trading_permitted: bool,
	start_time: u64,
	checks: TradeChecks,
	positions: Table<address, Position>,
	special_fee: Table<address, SpecialFee>,
	price_oracle: u128,
	funding: FundingRate,
	price_identifier_id: vector<u8>
}
struct SpecialFee has copy, drop, store {
	status: bool,
	maker_fee: u128,
	taker_fee: u128
}
public set_trading_permit(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: bool) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[3](Arg3: bool)
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[0](Perpetual.is_trading_permitted: bool)
WriteRef
MoveLoc[3](Arg3: bool)
Pack[4](TradingPermissionStatusUpdateEvent)
Call event::emit<TradingPermissionStatusUpdateEvent>(TradingPermissionStatusUpdateEvent)
Ret
}
public set_price_oracle_identifier(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: vector<u8>) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[3](Arg3: vector<u8>)
CopyLoc[2](Arg2: &mut Perpetual)
MutBorrowField[1](Perpetual.price_identifier_id: vector<u8>)
WriteRef
MoveLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
MoveLoc[3](Arg3: vector<u8>)
Pack[8](PriceOracleIdentifierUpdateEvent)
Call event::emit<PriceOracleIdentifierUpdateEvent>(PriceOracleIdentifierUpdateEvent)
Ret
}
public set_fee_pool_address<Ty0>(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Bank<Ty0>, Arg3: &mut Perpetual, Arg4: address) {
L5:	loc0: ID
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[4](Arg4: address)
LdConst[2](address: 0x00..)
Neq
BrFalse(10)
B1:
Branch(16)
B2:
MoveLoc[3](Arg3: &mut Perpetual)
Pop
MoveLoc[2](Arg2: &mut Bank<Ty0>)
Pop
LdU64(105)
Abort
B3:
CopyLoc[3](Arg3: &mut Perpetual)
FreezeRef
Call id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
StLoc[5](loc0: ID)
CopyLoc[4](Arg4: address)
CopyLoc[3](Arg3: &mut Perpetual)
MutBorrowField[2](Perpetual.fee_pool: address)
WriteRef
MoveLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[3](Arg3: &mut Perpetual)
ImmBorrowField[2](Perpetual.fee_pool: address)
ReadRef
Call bank::create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
MoveLoc[5](loc0: ID)
MoveLoc[4](Arg4: address)
Pack[1](FeePoolAccountUpdateEvent)
Call event::emit<FeePoolAccountUpdateEvent>(FeePoolAccountUpdateEvent)
Ret
}
public set_gas_pool_address<Ty0>(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Bank<Ty0>, Arg3: &mut Perpetual, Arg4: address) {
L5:	loc0: ID
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[4](Arg4: address)
LdConst[2](address: 0x00..)
Neq
BrFalse(10)
B1:
Branch(16)
B2:
MoveLoc[3](Arg3: &mut Perpetual)
Pop
MoveLoc[2](Arg2: &mut Bank<Ty0>)
Pop
LdU64(105)
Abort
B3:
CopyLoc[3](Arg3: &mut Perpetual)
FreezeRef
Call id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
StLoc[5](loc0: ID)
CopyLoc[4](Arg4: address)
CopyLoc[3](Arg3: &mut Perpetual)
MutBorrowField[3](Perpetual.gas_pool: address)
WriteRef
MoveLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[3](Arg3: &mut Perpetual)
ImmBorrowField[3](Perpetual.gas_pool: address)
ReadRef
Call bank::create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
MoveLoc[5](loc0: ID)
MoveLoc[4](Arg4: address)
Pack[2](GasPoolAccountUpdateEvent)
Call event::emit<GasPoolAccountUpdateEvent>(GasPoolAccountUpdateEvent)
Ret
}
public set_insurance_active_pool_address<Ty0>(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Bank<Ty0>, Arg3: &mut Perpetual, Arg4: address) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
MoveLoc[3](Arg3: &mut Perpetual)
MutBorrowField[4](Perpetual.insurance_fund: InsuranceFund)
CopyLoc[4](Arg4: address)
Call insurance_fund::set_active_account(&mut InsuranceFund, address)
MoveLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[4](Arg4: address)
Call bank::create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
Ret
}
public set_insurance_security_pool_address<Ty0>(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Bank<Ty0>, Arg3: &mut Perpetual, Arg4: address) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
MoveLoc[3](Arg3: &mut Perpetual)
MutBorrowField[4](Perpetual.insurance_fund: InsuranceFund)
CopyLoc[4](Arg4: address)
Call insurance_fund::set_security_account(&mut InsuranceFund, address)
MoveLoc[2](Arg2: &mut Bank<Ty0>)
MoveLoc[4](Arg4: address)
Call bank::create_account_if_not_exist<Ty0>(&mut Bank<Ty0>, address)
Ret
}
public transfer_insurance_fund_from_active_to_security_v2<Ty0>(Arg0: &Clock, Arg1: &ProtocolConfig, Arg2: &InsuranceOperatorCap, Arg3: &mut TxIndexer, Arg4: &mut Bank<Ty0>, Arg5: &Perpetual, Arg6: u128) {
L7:	loc0: u128
B0:
CopyLoc[1](Arg1: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[1](Arg1: &ProtocolConfig)
MoveLoc[2](Arg2: &InsuranceOperatorCap)
Call roles::check_insurance_operator_validity(&ProtocolConfig, &InsuranceOperatorCap)
MoveLoc[3](Arg3: &mut TxIndexer)
Call sub_accounts::increment_tx_index(&mut TxIndexer): u128
StLoc[7](loc0: u128)
MoveLoc[5](Arg5: &Perpetual)
Call insurance_fund(&Perpetual): &InsuranceFund
MoveLoc[0](Arg0: &Clock)
MoveLoc[4](Arg4: &mut Bank<Ty0>)
MoveLoc[6](Arg6: u128)
Call library::decimal_1e18_to_base(u128): u128
MoveLoc[7](loc0: u128)
Call insurance_fund::transfer_from_active_to_security<Ty0>(&InsuranceFund, &Clock, &mut Bank<Ty0>, u128, u128)
Ret
}
public transfer_insurance_fund_from_active_to_security<Ty0>(Arg0: &Clock, Arg1: &ProtocolConfig, Arg2: &ExchangeManagerCap, Arg3: &mut TxIndexer, Arg4: &mut Bank<Ty0>, Arg5: &Perpetual, Arg6: u128) {
B0:
LdU64(999)
Abort
}
public transfer_insurance_fund_from_security_to_active_v2<Ty0>(Arg0: &Clock, Arg1: &ProtocolConfig, Arg2: &InsuranceOperatorCap, Arg3: &mut TxIndexer, Arg4: &mut Bank<Ty0>, Arg5: &mut Perpetual, Arg6: u128) {
L7:	loc0: u128
B0:
CopyLoc[1](Arg1: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[1](Arg1: &ProtocolConfig)
MoveLoc[2](Arg2: &InsuranceOperatorCap)
Call roles::check_insurance_operator_validity(&ProtocolConfig, &InsuranceOperatorCap)
MoveLoc[3](Arg3: &mut TxIndexer)
Call sub_accounts::increment_tx_index(&mut TxIndexer): u128
StLoc[7](loc0: u128)
MoveLoc[5](Arg5: &mut Perpetual)
Call insurance_fund_mut(&mut Perpetual): &mut InsuranceFund
MoveLoc[0](Arg0: &Clock)
MoveLoc[4](Arg4: &mut Bank<Ty0>)
MoveLoc[6](Arg6: u128)
Call library::decimal_1e18_to_base(u128): u128
MoveLoc[7](loc0: u128)
Call insurance_fund::transfer_from_security_to_active<Ty0>(&mut InsuranceFund, &Clock, &mut Bank<Ty0>, u128, u128)
Ret
}
public transfer_insurance_fund_from_security_to_active<Ty0>(Arg0: &Clock, Arg1: &ProtocolConfig, Arg2: &ExchangeManagerCap, Arg3: &mut TxIndexer, Arg4: &mut Bank<Ty0>, Arg5: &mut Perpetual, Arg6: u128) {
B0:
LdU64(999)
Abort
}
public set_insurance_fund_transfer_amount_limit(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
MoveLoc[2](Arg2: &mut Perpetual)
Call insurance_fund_mut(&mut Perpetual): &mut InsuranceFund
MoveLoc[3](Arg3: u128)
Call library::decimal_1e18_to_base(u128): u128
Call insurance_fund::set_amount_limit(&mut InsuranceFund, u128)
Ret
}
public set_insurance_fund_transfer_interval(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u64) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
MoveLoc[2](Arg2: &mut Perpetual)
Call insurance_fund_mut(&mut Perpetual): &mut InsuranceFund
MoveLoc[3](Arg3: u64)
Call insurance_fund::set_transfer_interval(&mut InsuranceFund, u64)
Ret
}
public delist_perpetual(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
StLoc[3](Arg3: u128)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[5](Perpetual.delisted: bool)
ReadRef
Not
BrFalse(15)
B1:
Branch(19)
B2:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
LdU64(60)
Abort
B3:
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[6](Perpetual.checks: TradeChecks)
ReadRef
CopyLoc[3](Arg3: u128)
Call evaluator::verify_price_checks(TradeChecks, u128)
LdTrue
CopyLoc[2](Arg2: &mut Perpetual)
MutBorrowField[5](Perpetual.delisted: bool)
WriteRef
CopyLoc[3](Arg3: u128)
CopyLoc[2](Arg2: &mut Perpetual)
MutBorrowField[7](Perpetual.delisting_price: u128)
WriteRef
MoveLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
MoveLoc[3](Arg3: u128)
Pack[3](DelistEvent)
Call event::emit<DelistEvent>(DelistEvent)
Ret
}
public set_min_price(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[6](Perpetual.checks: TradeChecks)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
Call evaluator::set_min_price(ID, &mut TradeChecks, u128)
Ret
}
public set_max_price(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[6](Perpetual.checks: TradeChecks)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
Call evaluator::set_max_price(ID, &mut TradeChecks, u128)
Ret
}
public set_step_size(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[6](Perpetual.checks: TradeChecks)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
Call evaluator::set_step_size(ID, &mut TradeChecks, u128)
Ret
}
public set_tick_size(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[6](Perpetual.checks: TradeChecks)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
Call evaluator::set_tick_size(ID, &mut TradeChecks, u128)
Ret
}
public set_mtb_long(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[6](Perpetual.checks: TradeChecks)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
Call evaluator::set_mtb_long(ID, &mut TradeChecks, u128)
Ret
}
public set_mtb_short(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[6](Perpetual.checks: TradeChecks)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
Call evaluator::set_mtb_short(ID, &mut TradeChecks, u128)
Ret
}
public set_max_qty_limit(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[6](Perpetual.checks: TradeChecks)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
Call evaluator::set_max_qty_limit(ID, &mut TradeChecks, u128)
Ret
}
public set_max_qty_market(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[6](Perpetual.checks: TradeChecks)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
Call evaluator::set_max_qty_market(ID, &mut TradeChecks, u128)
Ret
}
public set_min_qty(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[6](Perpetual.checks: TradeChecks)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
Call evaluator::set_min_qty(ID, &mut TradeChecks, u128)
Ret
}
public set_max_oi_open(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: vector<u128>) {
L4:	loc0: vector<u128>
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
MoveLoc[3](Arg3: vector<u128>)
Call library::to_1x9_vec(vector<u128>): vector<u128>
StLoc[4](loc0: vector<u128>)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[6](Perpetual.checks: TradeChecks)
MoveLoc[4](loc0: vector<u128>)
Call evaluator::set_max_oi_open(ID, &mut TradeChecks, vector<u128>)
Ret
}
public set_max_allowed_funding_rate(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
L4:	loc0: ID
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
StLoc[4](loc0: ID)
MoveLoc[2](Arg2: &mut Perpetual)
MutBorrowField[9](Perpetual.funding: FundingRate)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
MoveLoc[4](loc0: ID)
Call funding_rate::set_max_allowed_funding_rate(&mut FundingRate, u128, ID)
Ret
}
public set_funding_rate(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &FundingRateCap, Arg3: &mut Perpetual, Arg4: u128, Arg5: bool, Arg6: &PriceInfoObject) {
B0:
LdU64(999)
Abort
}
public set_funding_rate_v2(Arg0: &ProtocolConfig, Arg1: &Clock, Arg2: &FundingRateCap, Arg3: &mut Perpetual, Arg4: u128, Arg5: bool, Arg6: &PriceFeed) {
L7:	loc0: FundingIndex
L8:	loc1: ID
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[2](Arg2: &FundingRateCap)
Call roles::check_funding_rate_operator_validity(&ProtocolConfig, &FundingRateCap)
CopyLoc[3](Arg3: &mut Perpetual)
ImmBorrowField[5](Perpetual.delisted: bool)
ReadRef
Not
BrFalse(11)
B1:
Branch(19)
B2:
MoveLoc[6](Arg6: &PriceFeed)
Pop
MoveLoc[3](Arg3: &mut Perpetual)
Pop
MoveLoc[1](Arg1: &Clock)
Pop
LdU64(61)
Abort
B3:
CopyLoc[3](Arg3: &mut Perpetual)
MoveLoc[6](Arg6: &PriceFeed)
CopyLoc[1](Arg1: &Clock)
Call update_oracle_price_v2(&mut Perpetual, &PriceFeed, &Clock)
CopyLoc[3](Arg3: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
StLoc[8](loc1: ID)
CopyLoc[1](Arg1: &Clock)
CopyLoc[3](Arg3: &mut Perpetual)
ImmBorrowField[9](Perpetual.funding: FundingRate)
ReadRef
CopyLoc[3](Arg3: &mut Perpetual)
FreezeRef
Call price_oracle(&Perpetual): u128
Call funding_rate::compute_new_global_index(&Clock, FundingRate, u128): FundingIndex
StLoc[7](loc0: FundingIndex)
CopyLoc[3](Arg3: &mut Perpetual)
MutBorrowField[9](Perpetual.funding: FundingRate)
MoveLoc[7](loc0: FundingIndex)
CopyLoc[8](loc1: ID)
Call funding_rate::set_global_index(&mut FundingRate, FundingIndex, ID)
MoveLoc[3](Arg3: &mut Perpetual)
MutBorrowField[9](Perpetual.funding: FundingRate)
MoveLoc[4](Arg4: u128)
Call library::base_uint(): u128
Div
MoveLoc[5](Arg5: bool)
MoveLoc[1](Arg1: &Clock)
Call clock::timestamp_ms(&Clock): u64
MoveLoc[8](loc1: ID)
Call funding_rate::set_funding_rate(&mut FundingRate, u128, bool, u64, ID)
Ret
}
public set_maintenance_margin_required(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
StLoc[3](Arg3: u128)
CopyLoc[3](Arg3: u128)
LdU128(0)
Gt
BrFalse(14)
B1:
Branch(18)
B2:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
LdU64(300)
Abort
B3:
CopyLoc[3](Arg3: u128)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[10](Perpetual.imr: u128)
ReadRef
Le
BrFalse(25)
B4:
Branch(29)
B5:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
LdU64(301)
Abort
B6:
CopyLoc[3](Arg3: u128)
CopyLoc[2](Arg2: &mut Perpetual)
MutBorrowField[11](Perpetual.mmr: u128)
WriteRef
MoveLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
MoveLoc[3](Arg3: u128)
Pack[5](MMRUpdateEvent)
Call event::emit<MMRUpdateEvent>(MMRUpdateEvent)
Ret
}
public set_initial_margin_required(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
StLoc[3](Arg3: u128)
CopyLoc[3](Arg3: u128)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[11](Perpetual.mmr: u128)
ReadRef
Ge
BrFalse(16)
B1:
Branch(20)
B2:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
LdU64(302)
Abort
B3:
CopyLoc[3](Arg3: u128)
CopyLoc[2](Arg2: &mut Perpetual)
MutBorrowField[10](Perpetual.imr: u128)
WriteRef
MoveLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
MoveLoc[3](Arg3: u128)
Pack[6](IMRUpdateEvent)
Call event::emit<IMRUpdateEvent>(IMRUpdateEvent)
Ret
}
public set_special_fee(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: address, Arg4: bool, Arg5: u128, Arg6: u128) {
L7:	loc0: &mut SpecialFee
L8:	loc1: SpecialFee
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[3](Arg3: address)
LdConst[2](address: 0x00..)
Neq
BrFalse(10)
B1:
Branch(14)
B2:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
LdU64(105)
Abort
B3:
CopyLoc[4](Arg4: bool)
MoveLoc[5](Arg5: u128)
Call library::base_uint(): u128
Div
MoveLoc[6](Arg6: u128)
Call library::base_uint(): u128
Div
Pack[12](SpecialFee)
StLoc[8](loc1: SpecialFee)
CopyLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[12](Perpetual.special_fee: Table<address, SpecialFee>)
CopyLoc[3](Arg3: address)
Call table::contains<address, SpecialFee>(&Table<address, SpecialFee>, address): bool
BrFalse(37)
B4:
CopyLoc[2](Arg2: &mut Perpetual)
MutBorrowField[12](Perpetual.special_fee: Table<address, SpecialFee>)
CopyLoc[3](Arg3: address)
Call table::borrow_mut<address, SpecialFee>(&mut Table<address, SpecialFee>, address): &mut SpecialFee
StLoc[7](loc0: &mut SpecialFee)
CopyLoc[8](loc1: SpecialFee)
MoveLoc[7](loc0: &mut SpecialFee)
WriteRef
Branch(42)
B5:
CopyLoc[2](Arg2: &mut Perpetual)
MutBorrowField[12](Perpetual.special_fee: Table<address, SpecialFee>)
CopyLoc[3](Arg3: address)
CopyLoc[8](loc1: SpecialFee)
Call table::add<address, SpecialFee>(&mut Table<address, SpecialFee>, address, SpecialFee)
B6:
MoveLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
MoveLoc[3](Arg3: address)
MoveLoc[4](Arg4: bool)
ImmBorrowLoc[8](loc1: SpecialFee)
ImmBorrowField[13](SpecialFee.maker_fee: u128)
ReadRef
ImmBorrowLoc[8](loc1: SpecialFee)
ImmBorrowField[14](SpecialFee.taker_fee: u128)
ReadRef
Pack[7](SpecialFeeEvent)
Call event::emit<SpecialFeeEvent>(SpecialFeeEvent)
Ret
}
public remove_empty_positions(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &Clock, Arg3: &mut Perpetual, Arg4: vector<address>) {
L5:	loc0: u64
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
MoveLoc[2](Arg2: &Clock)
Call clock::timestamp_ms(&Clock): u64
StLoc[5](loc0: u64)
MoveLoc[3](Arg3: &mut Perpetual)
Call positions(&mut Perpetual): &mut Table<address, Position>
MoveLoc[4](Arg4: vector<address>)
MoveLoc[5](loc0: u64)
Call position::remove_empty_positions(&mut Table<address, Position>, vector<address>, u64)
Ret
}
public set_maker_fee(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
L4:	loc0: u128
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
StLoc[4](loc0: u128)
CopyLoc[4](loc0: u128)
Call library::base_uint(): u128
Le
BrFalse(14)
B1:
Branch(18)
B2:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
LdU64(99999)
Abort
B3:
MoveLoc[4](loc0: u128)
CopyLoc[2](Arg2: &mut Perpetual)
MutBorrowField[15](Perpetual.maker_fee: u128)
WriteRef
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[15](Perpetual.maker_fee: u128)
ReadRef
Pack[9](MakerFeeUpdateEvent)
Call event::emit<MakerFeeUpdateEvent>(MakerFeeUpdateEvent)
Ret
}
public set_taker_fee(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut Perpetual, Arg3: u128) {
L4:	loc0: u128
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
MoveLoc[3](Arg3: u128)
Call library::base_uint(): u128
Div
StLoc[4](loc0: u128)
CopyLoc[4](loc0: u128)
Call library::base_uint(): u128
Le
BrFalse(14)
B1:
Branch(18)
B2:
MoveLoc[2](Arg2: &mut Perpetual)
Pop
LdU64(99999)
Abort
B3:
MoveLoc[4](loc0: u128)
CopyLoc[2](Arg2: &mut Perpetual)
MutBorrowField[16](Perpetual.taker_fee: u128)
WriteRef
CopyLoc[2](Arg2: &mut Perpetual)
FreezeRef
Call id(&Perpetual): &UID
Call object::uid_to_inner(&UID): ID
MoveLoc[2](Arg2: &mut Perpetual)
ImmBorrowField[16](Perpetual.taker_fee: u128)
ReadRef
Pack[10](TakerFeeUpdateEvent)
Call event::emit<TakerFeeUpdateEvent>(TakerFeeUpdateEvent)
Ret
}
public(friend) create(Arg0: vector<u8>, Arg1: u128, Arg2: u128, Arg3: u128, Arg4: u128, Arg5: address, Arg6: address, Arg7: address, Arg8: address, Arg9: u128, Arg10: u128, Arg11: u128, Arg12: u128, Arg13: u128, Arg14: u128, Arg15: u128, Arg16: u128, Arg17: u128, Arg18: u128, Arg19: u64, Arg20: vector<u128>, Arg21: vector<u8>, Arg22: u64, Arg23: u128, Arg24: &mut TxContext): ID {
L25:	loc0: TradeChecks
L26:	loc1: FundingRate
L27:	loc2: UID
L28:	loc3: InsuranceFund
L29:	loc4: Perpetual
L30:	loc5: ID
L31:	loc6: Table<address, Position>
L32:	loc7: Table<address, SpecialFee>
B0:
CopyLoc[24](Arg24: &mut TxContext)
Call table::new<address, Position>(&mut TxContext): Table<address, Position>
StLoc[31](loc6: Table<address, Position>)
CopyLoc[24](Arg24: &mut TxContext)
Call table::new<address, SpecialFee>(&mut TxContext): Table<address, SpecialFee>
StLoc[32](loc7: Table<address, SpecialFee>)
MoveLoc[24](Arg24: &mut TxContext)
Call object::new(&mut TxContext): UID
StLoc[27](loc2: UID)
ImmBorrowLoc[27](loc2: UID)
Call object::uid_to_inner(&UID): ID
StLoc[30](loc5: ID)
CopyLoc[30](loc5: ID)
MoveLoc[5](Arg5: address)
MoveLoc[6](Arg6: address)
MoveLoc[22](Arg22: u64)
MoveLoc[23](Arg23: u128)
Call insurance_fund::create_insurance_fund(ID, address, address, u64, u128): InsuranceFund
StLoc[28](loc3: InsuranceFund)
MoveLoc[9](Arg9: u128)
MoveLoc[10](Arg10: u128)
MoveLoc[11](Arg11: u128)
MoveLoc[12](Arg12: u128)
MoveLoc[13](Arg13: u128)
MoveLoc[14](Arg14: u128)
MoveLoc[15](Arg15: u128)
MoveLoc[16](Arg16: u128)
MoveLoc[17](Arg17: u128)
MoveLoc[20](Arg20: vector<u128>)
Call evaluator::new_trade_checks(u128, u128, u128, u128, u128, u128, u128, u128, u128, vector<u128>): TradeChecks
StLoc[25](loc0: TradeChecks)
CopyLoc[19](Arg19: u64)
MoveLoc[18](Arg18: u128)
Call funding_rate::initialize(u64, u128): FundingRate
StLoc[26](loc1: FundingRate)
CopyLoc[2](Arg2: u128)
LdU128(0)
Gt
BrFalse(40)
B1:
Branch(42)
B2:
LdU64(300)
Abort
B3:
CopyLoc[2](Arg2: u128)
CopyLoc[1](Arg1: u128)
Le
BrFalse(47)
B4:
Branch(49)
B5:
LdU64(301)
Abort
B6:
MoveLoc[27](loc2: UID)
MoveLoc[0](Arg0: vector<u8>)
Call string::utf8(vector<u8>): String
CopyLoc[1](Arg1: u128)
CopyLoc[2](Arg2: u128)
CopyLoc[3](Arg3: u128)
CopyLoc[4](Arg4: u128)
MoveLoc[28](loc3: InsuranceFund)
CopyLoc[7](Arg7: address)
CopyLoc[8](Arg8: address)
LdFalse
LdU128(0)
LdTrue
CopyLoc[19](Arg19: u64)
CopyLoc[25](loc0: TradeChecks)
MoveLoc[31](loc6: Table<address, Position>)
MoveLoc[32](loc7: Table<address, SpecialFee>)
LdU128(0)
CopyLoc[26](loc1: FundingRate)
CopyLoc[21](Arg21: vector<u8>)
Pack[11](Perpetual)
StLoc[29](loc4: Perpetual)
CopyLoc[30](loc5: ID)
ImmBorrowLoc[29](loc4: Perpetual)
ImmBorrowField[17](Perpetual.name: String)
ReadRef
MoveLoc[1](Arg1: u128)
MoveLoc[2](Arg2: u128)
MoveLoc[3](Arg3: u128)
MoveLoc[4](Arg4: u128)
MoveLoc[7](Arg7: address)
MoveLoc[8](Arg8: address)
MoveLoc[19](Arg19: u64)
MoveLoc[21](Arg21: vector<u8>)
MoveLoc[25](loc0: TradeChecks)
MoveLoc[26](loc1: FundingRate)
Pack[0](PerpetualCreationEvent)
Call event::emit<PerpetualCreationEvent>(PerpetualCreationEvent)
MoveLoc[29](loc4: Perpetual)
Call transfer::share_object<Perpetual>(Perpetual)
MoveLoc[30](loc5: ID)
Ret
}
public(friend) positions(Arg0: &mut Perpetual): &mut Table<address, Position> {
B0:
MoveLoc[0](Arg0: &mut Perpetual)
MutBorrowField[18](Perpetual.positions: Table<address, Position>)
Ret
}
public(friend) borrow_position(Arg0: &Perpetual, Arg1: address): &Position {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[18](Perpetual.positions: Table<address, Position>)
MoveLoc[1](Arg1: address)
Call table::borrow<address, Position>(&Table<address, Position>, address): &Position
Ret
}
public(friend) has_position(Arg0: &Perpetual, Arg1: address): bool {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[18](Perpetual.positions: Table<address, Position>)
MoveLoc[1](Arg1: address)
Call table::contains<address, Position>(&Table<address, Position>, address): bool
Ret
}
public(friend) id(Arg0: &Perpetual): &UID {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Ret
}
public(friend) perp_address(Arg0: &Perpetual): address {
L1:	loc0: ID
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
StLoc[1](loc0: ID)
ImmBorrowLoc[1](loc0: ID)
Call object::id_to_address(&ID): address
Ret
}
public(friend) name(Arg0: &Perpetual): &String {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[17](Perpetual.name: String)
Ret
}
public(friend) checks(Arg0: &Perpetual): TradeChecks {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[6](Perpetual.checks: TradeChecks)
ReadRef
Ret
}
public(friend) imr(Arg0: &Perpetual): u128 {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[10](Perpetual.imr: u128)
ReadRef
Ret
}
public(friend) mmr(Arg0: &Perpetual): u128 {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[11](Perpetual.mmr: u128)
ReadRef
Ret
}
public(friend) maker_fee(Arg0: &Perpetual): u128 {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[15](Perpetual.maker_fee: u128)
ReadRef
Ret
}
public(friend) taker_fee(Arg0: &Perpetual): u128 {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[16](Perpetual.taker_fee: u128)
ReadRef
Ret
}
public(friend) funding_rate(Arg0: &Perpetual): FundingRate {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[9](Perpetual.funding: FundingRate)
ReadRef
Ret
}
public(friend) funding_rate_mut(Arg0: &mut Perpetual): &mut FundingRate {
B0:
MoveLoc[0](Arg0: &mut Perpetual)
MutBorrowField[9](Perpetual.funding: FundingRate)
Ret
}
public(friend) insurance_fund(Arg0: &Perpetual): &InsuranceFund {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[4](Perpetual.insurance_fund: InsuranceFund)
Ret
}
public(friend) insurance_fund_mut(Arg0: &mut Perpetual): &mut InsuranceFund {
B0:
MoveLoc[0](Arg0: &mut Perpetual)
MutBorrowField[4](Perpetual.insurance_fund: InsuranceFund)
Ret
}
public(friend) insurance_active_pool(Arg0: &Perpetual): address {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[4](Perpetual.insurance_fund: InsuranceFund)
Call insurance_fund::active_account(&InsuranceFund): address
Ret
}
public(friend) insurance_security_pool(Arg0: &Perpetual): address {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[4](Perpetual.insurance_fund: InsuranceFund)
Call insurance_fund::security_account(&InsuranceFund): address
Ret
}
public(friend) fee_pool(Arg0: &Perpetual): address {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[2](Perpetual.fee_pool: address)
ReadRef
Ret
}
public(friend) gas_pool(Arg0: &Perpetual): address {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[3](Perpetual.gas_pool: address)
ReadRef
Ret
}
public(friend) price_oracle(Arg0: &Perpetual): u128 {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[19](Perpetual.price_oracle: u128)
ReadRef
Ret
}
public(friend) global_index(Arg0: &Perpetual): FundingIndex {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[9](Perpetual.funding: FundingRate)
ReadRef
Call funding_rate::index(FundingRate): FundingIndex
Ret
}
public(friend) is_trading_permitted(Arg0: &Perpetual): bool {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[0](Perpetual.is_trading_permitted: bool)
ReadRef
Ret
}
public(friend) delisted(Arg0: &Perpetual): bool {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[5](Perpetual.delisted: bool)
ReadRef
Ret
}
public(friend) delisting_price(Arg0: &Perpetual): u128 {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[7](Perpetual.delisting_price: u128)
ReadRef
Ret
}
public(friend) start_time(Arg0: &Perpetual): u64 {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[20](Perpetual.start_time: u64)
ReadRef
Ret
}
public(friend) price_identifier(Arg0: &Perpetual): vector<u8> {
B0:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[1](Perpetual.price_identifier_id: vector<u8>)
ReadRef
Ret
}
public(friend) get_fee(Arg0: &Perpetual, Arg1: address, Arg2: bool): u128 {
L3:	loc0: &SpecialFee
B0:
CopyLoc[0](Arg0: &Perpetual)
ImmBorrowField[12](Perpetual.special_fee: Table<address, SpecialFee>)
CopyLoc[1](Arg1: address)
Call table::contains<address, SpecialFee>(&Table<address, SpecialFee>, address): bool
BrFalse(28)
B1:
CopyLoc[0](Arg0: &Perpetual)
ImmBorrowField[12](Perpetual.special_fee: Table<address, SpecialFee>)
MoveLoc[1](Arg1: address)
Call table::borrow<address, SpecialFee>(&Table<address, SpecialFee>, address): &SpecialFee
StLoc[3](loc0: &SpecialFee)
CopyLoc[3](loc0: &SpecialFee)
ImmBorrowField[21](SpecialFee.status: bool)
ReadRef
BrFalse(26)
B2:
MoveLoc[0](Arg0: &Perpetual)
Pop
MoveLoc[2](Arg2: bool)
BrFalse(22)
B3:
MoveLoc[3](loc0: &SpecialFee)
ImmBorrowField[13](SpecialFee.maker_fee: u128)
ReadRef
Ret
B4:
MoveLoc[3](loc0: &SpecialFee)
ImmBorrowField[14](SpecialFee.taker_fee: u128)
ReadRef
Ret
B5:
MoveLoc[3](loc0: &SpecialFee)
Pop
B6:
MoveLoc[2](Arg2: bool)
BrFalse(34)
B7:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[15](Perpetual.maker_fee: u128)
ReadRef
Ret
B8:
MoveLoc[0](Arg0: &Perpetual)
ImmBorrowField[16](Perpetual.taker_fee: u128)
ReadRef
Ret
}
public(friend) update_oracle_price_v2(Arg0: &mut Perpetual, Arg1: &PriceFeed, Arg2: &Clock) {
L3:	loc0: u64
L4:	loc1: u64
L5:	loc2: u64
L6:	loc3: u128
L7:	loc4: ID
L8:	loc5: &PriceInfo
L9:	loc6: u64
B0:
CopyLoc[0](Arg0: &mut Perpetual)
ImmBorrowField[8](Perpetual.id: UID)
Call object::uid_to_inner(&UID): ID
StLoc[7](loc4: ID)
CopyLoc[1](Arg1: &PriceFeed)
ImmBorrowLoc[7](loc4: ID)
Call price_feed::contains(&PriceFeed, &ID): bool
BrFalse(9)
B1:
Branch(17)
B2:
MoveLoc[1](Arg1: &PriceFeed)
Pop
MoveLoc[0](Arg0: &mut Perpetual)
Pop
MoveLoc[2](Arg2: &Clock)
Pop
LdU64(903)
Abort
B3:
MoveLoc[1](Arg1: &PriceFeed)
ImmBorrowLoc[7](loc4: ID)
Call price_feed::get_price_info(&PriceFeed, &ID): &PriceInfo
StLoc[8](loc5: &PriceInfo)
MoveLoc[2](Arg2: &Clock)
Call clock::timestamp_ms(&Clock): u64
StLoc[5](loc2: u64)
CopyLoc[5](loc2: u64)
LdConst[1](u64: 5000)
Add
StLoc[4](loc1: u64)
CopyLoc[8](loc5: &PriceInfo)
Call price_feed::price_info_timestamp(&PriceInfo): u64
StLoc[9](loc6: u64)
CopyLoc[9](loc6: u64)
MoveLoc[4](loc1: u64)
Le
BrFalse(36)
B4:
Branch(42)
B5:
MoveLoc[8](loc5: &PriceInfo)
Pop
MoveLoc[0](Arg0: &mut Perpetual)
Pop
LdU64(912)
Abort
B6:
CopyLoc[9](loc6: u64)
CopyLoc[5](loc2: u64)
Gt
BrFalse(49)
B7:
LdU64(0)
StLoc[3](loc0: u64)
Branch(53)
B8:
MoveLoc[5](loc2: u64)
MoveLoc[9](loc6: u64)
Sub
StLoc[3](loc0: u64)
B9:
MoveLoc[3](loc0: u64)
LdConst[0](u64: 60000)
Le
BrFalse(58)
B10:
Branch(64)
B11:
MoveLoc[8](loc5: &PriceInfo)
Pop
MoveLoc[0](Arg0: &mut Perpetual)
Pop
LdU64(913)
Abort
B12:
MoveLoc[8](loc5: &PriceInfo)
Call price_feed::price_info_price(&PriceInfo): u128
StLoc[6](loc3: u128)
CopyLoc[6](loc3: u128)
LdU128(0)
Gt
BrFalse(72)
B13:
Branch(76)
B14:
MoveLoc[0](Arg0: &mut Perpetual)
Pop
LdU64(909)
Abort
B15:
MoveLoc[6](loc3: u128)
MoveLoc[0](Arg0: &mut Perpetual)
MutBorrowField[19](Perpetual.price_oracle: u128)
WriteRef
Ret
}
Constants [
=> u64: 60000
=> u64: 5000
=> address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/position.mvb691 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.position {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::funding_rate;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::s128;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
struct AccountPositionUpdateEvent has copy, drop {
	tx_index: u128,
	position: Position,
	sender: address,
	action: u8
}
struct PositionClosedEvent has copy, drop {
	tx_index: u128,
	perp_id: ID,
	account: address,
	amount: u128
}
struct Position has copy, drop, store {
	user: address,
	perp_id: ID,
	is_long: bool,
	size: u128,
	margin: u128,
	oi_open: u128,
	mro: u128,
	index: FundingIndex
}
public(friend) empty_position(Arg0: ID, Arg1: address): Position {
B0:
MoveLoc[1](Arg1: address)
MoveLoc[0](Arg0: ID)
LdFalse
LdU128(0)
LdU128(0)
LdU128(0)
LdU128(0)
LdU64(0)
Call funding_rate::new_index(u64): FundingIndex
Pack[2](Position)
Ret
}
public(friend) is_long(Arg0: &Position): bool {
B0:
MoveLoc[0](Arg0: &Position)
ImmBorrowField[0](Position.is_long: bool)
ReadRef
Ret
}
public(friend) size(Arg0: &Position): u128 {
B0:
MoveLoc[0](Arg0: &Position)
ImmBorrowField[1](Position.size: u128)
ReadRef
Ret
}
public(friend) margin(Arg0: &Position): u128 {
B0:
MoveLoc[0](Arg0: &Position)
ImmBorrowField[2](Position.margin: u128)
ReadRef
Ret
}
public(friend) oi_open(Arg0: &Position): u128 {
B0:
MoveLoc[0](Arg0: &Position)
ImmBorrowField[3](Position.oi_open: u128)
ReadRef
Ret
}
public(friend) mro(Arg0: &Position): u128 {
B0:
MoveLoc[0](Arg0: &Position)
ImmBorrowField[4](Position.mro: u128)
ReadRef
Ret
}
public(friend) user(Arg0: &Position): address {
B0:
MoveLoc[0](Arg0: &Position)
ImmBorrowField[5](Position.user: address)
ReadRef
Ret
}
public(friend) index(Arg0: &Position): FundingIndex {
B0:
MoveLoc[0](Arg0: &Position)
ImmBorrowField[6](Position.index: FundingIndex)
ReadRef
Ret
}
public(friend) set_mro(Arg0: &mut Position, Arg1: u128) {
B0:
CopyLoc[0](Arg0: &mut Position)
ImmBorrowField[1](Position.size: u128)
ReadRef
LdU128(0)
Eq
BrFalse(11)
B1:
LdU128(0)
MoveLoc[0](Arg0: &mut Position)
MutBorrowField[4](Position.mro: u128)
WriteRef
Branch(15)
B2:
MoveLoc[1](Arg1: u128)
MoveLoc[0](Arg0: &mut Position)
MutBorrowField[4](Position.mro: u128)
WriteRef
B3:
Ret
}
public(friend) set_oi_open(Arg0: &mut Position, Arg1: u128) {
B0:
MoveLoc[1](Arg1: u128)
MoveLoc[0](Arg0: &mut Position)
MutBorrowField[3](Position.oi_open: u128)
WriteRef
Ret
}
public(friend) set_margin(Arg0: &mut Position, Arg1: u128) {
B0:
MoveLoc[1](Arg1: u128)
MoveLoc[0](Arg0: &mut Position)
MutBorrowField[2](Position.margin: u128)
WriteRef
Ret
}
public(friend) set_size(Arg0: &mut Position, Arg1: u128) {
B0:
CopyLoc[1](Arg1: u128)
CopyLoc[0](Arg0: &mut Position)
MutBorrowField[1](Position.size: u128)
WriteRef
MoveLoc[1](Arg1: u128)
LdU128(0)
Eq
BrFalse(15)
B1:
CopyLoc[0](Arg0: &mut Position)
LdFalse
Call set_is_long(&mut Position, bool)
MoveLoc[0](Arg0: &mut Position)
LdU128(0)
Call set_mro(&mut Position, u128)
Branch(17)
B2:
MoveLoc[0](Arg0: &mut Position)
Pop
B3:
Ret
}
public(friend) set_is_long(Arg0: &mut Position, Arg1: bool) {
B0:
MoveLoc[1](Arg1: bool)
MoveLoc[0](Arg0: &mut Position)
MutBorrowField[0](Position.is_long: bool)
WriteRef
Ret
}
public(friend) set_index(Arg0: &mut Position, Arg1: FundingIndex) {
B0:
MoveLoc[1](Arg1: FundingIndex)
MoveLoc[0](Arg0: &mut Position)
MutBorrowField[6](Position.index: FundingIndex)
WriteRef
Ret
}
public(friend) compute_margin_ratio(Arg0: &Position, Arg1: u128): S128 {
L2:	loc0: S128
L3:	loc1: S128
L4:	loc2: u128
B0:
Call s128::one(): S128
StLoc[3](loc1: S128)
CopyLoc[0](Arg0: &Position)
ImmBorrowField[1](Position.size: u128)
ReadRef
LdU128(0)
Eq
BrFalse(12)
B1:
MoveLoc[0](Arg0: &Position)
Pop
MoveLoc[3](loc1: S128)
Ret
B2:
MoveLoc[1](Arg1: u128)
CopyLoc[0](Arg0: &Position)
ImmBorrowField[1](Position.size: u128)
ReadRef
Call library::base_mul(u128, u128): u128
StLoc[4](loc2: u128)
CopyLoc[4](loc2: u128)
LdU128(0)
Eq
BrFalse(26)
B3:
MoveLoc[0](Arg0: &Position)
Pop
Call s128::zero(): S128
Ret
B4:
CopyLoc[0](Arg0: &Position)
ImmBorrowField[0](Position.is_long: bool)
ReadRef
BrFalse(45)
B5:
CopyLoc[0](Arg0: &Position)
ImmBorrowField[3](Position.oi_open: u128)
ReadRef
MoveLoc[0](Arg0: &Position)
ImmBorrowField[2](Position.margin: u128)
ReadRef
Call s128::from_subtraction(u128, u128): S128
MoveLoc[4](loc2: u128)
Call s128::div_u128(S128, u128): S128
StLoc[2](loc0: S128)
MoveLoc[3](loc1: S128)
MoveLoc[2](loc0: S128)
Call s128::sub(S128, S128): S128
StLoc[3](loc1: S128)
Branch(57)
B6:
CopyLoc[0](Arg0: &Position)
ImmBorrowField[3](Position.oi_open: u128)
ReadRef
MoveLoc[0](Arg0: &Position)
ImmBorrowField[2](Position.margin: u128)
ReadRef
Add
MoveLoc[4](loc2: u128)
Call library::base_div(u128, u128): u128
Call library::base_uint(): u128
Call s128::from_subtraction(u128, u128): S128
StLoc[3](loc1: S128)
B7:
MoveLoc[3](loc1: S128)
Ret
}
public(friend) compute_average_entry_price(Arg0: &Position): u128 {
L1:	loc0: u128
B0:
CopyLoc[0](Arg0: &Position)
ImmBorrowField[1](Position.size: u128)
ReadRef
LdU128(0)
Eq
BrFalse(11)
B1:
MoveLoc[0](Arg0: &Position)
Pop
LdU128(0)
StLoc[1](loc0: u128)
Branch(19)
B2:
CopyLoc[0](Arg0: &Position)
ImmBorrowField[3](Position.oi_open: u128)
ReadRef
MoveLoc[0](Arg0: &Position)
ImmBorrowField[1](Position.size: u128)
ReadRef
Call library::base_div(u128, u128): u128
StLoc[1](loc0: u128)
B3:
MoveLoc[1](loc0: u128)
Ret
}
public(friend) create_position(Arg0: ID, Arg1: &mut Table<address, Position>, Arg2: address) {
B0:
CopyLoc[1](Arg1: &mut Table<address, Position>)
FreezeRef
CopyLoc[2](Arg2: address)
Call table::contains<address, Position>(&Table<address, Position>, address): bool
Not
BrFalse(13)
B1:
MoveLoc[1](Arg1: &mut Table<address, Position>)
CopyLoc[2](Arg2: address)
MoveLoc[0](Arg0: ID)
MoveLoc[2](Arg2: address)
Call empty_position(ID, address): Position
Call table::add<address, Position>(&mut Table<address, Position>, address, Position)
Branch(15)
B2:
MoveLoc[1](Arg1: &mut Table<address, Position>)
Pop
B3:
Ret
}
public(friend) remove_empty_positions(Arg0: &mut Table<address, Position>, Arg1: vector<address>, Arg2: u64) {
L3:	loc0: bool
L4:	loc1: address
L5:	loc2: u64
L6:	loc3: u64
L7:	loc4: &Position
B0:
ImmBorrowLoc[1](Arg1: vector<address>)
VecLen(5)
LdU64(1000)
Le
BrFalse(6)
B1:
Branch(10)
B2:
MoveLoc[0](Arg0: &mut Table<address, Position>)
Pop
LdU64(99999)
Abort
B3:
ImmBorrowLoc[1](Arg1: vector<address>)
VecLen(5)
StLoc[5](loc2: u64)
LdU64(0)
StLoc[6](loc3: u64)
B4:
CopyLoc[6](loc3: u64)
CopyLoc[5](loc2: u64)
Lt
BrFalse(65)
B5:
ImmBorrowLoc[1](Arg1: vector<address>)
CopyLoc[6](loc3: u64)
VecImmBorrow(5)
ReadRef
StLoc[4](loc1: address)
MoveLoc[6](loc3: u64)
LdU64(1)
Add
StLoc[6](loc3: u64)
CopyLoc[0](Arg0: &mut Table<address, Position>)
FreezeRef
CopyLoc[4](loc1: address)
Call table::contains<address, Position>(&Table<address, Position>, address): bool
BrFalse(15)
B6:
CopyLoc[0](Arg0: &mut Table<address, Position>)
FreezeRef
CopyLoc[4](loc1: address)
Call table::borrow<address, Position>(&Table<address, Position>, address): &Position
StLoc[7](loc4: &Position)
CopyLoc[7](loc4: &Position)
ImmBorrowField[1](Position.size: u128)
ReadRef
LdU128(0)
Eq
BrFalse(54)
B7:
CopyLoc[2](Arg2: u64)
MoveLoc[7](loc4: &Position)
ImmBorrowField[6](Position.index: FundingIndex)
ReadRef
Call funding_rate::index_timestamp(FundingIndex): u64
Sub
LdU64(604800000)
Gt
StLoc[3](loc0: bool)
Branch(58)
B8:
MoveLoc[7](loc4: &Position)
Pop
LdFalse
StLoc[3](loc0: bool)
B9:
MoveLoc[3](loc0: bool)
BrFalse(15)
B10:
CopyLoc[0](Arg0: &mut Table<address, Position>)
MoveLoc[4](loc1: address)
Call table::remove<address, Position>(&mut Table<address, Position>, address): Position
Pop
Branch(15)
B11:
MoveLoc[0](Arg0: &mut Table<address, Position>)
Pop
Ret
}
public(friend) emit_position_update_event(Arg0: Position, Arg1: address, Arg2: u8, Arg3: u128) {
B0:
MoveLoc[3](Arg3: u128)
MoveLoc[0](Arg0: Position)
MoveLoc[1](Arg1: address)
MoveLoc[2](Arg2: u8)
Pack[0](AccountPositionUpdateEvent)
Call event::emit<AccountPositionUpdateEvent>(AccountPositionUpdateEvent)
Ret
}
public(friend) emit_position_closed_event(Arg0: ID, Arg1: address, Arg2: u128, Arg3: u128) {
B0:
MoveLoc[3](Arg3: u128)
MoveLoc[0](Arg0: ID)
MoveLoc[1](Arg1: address)
MoveLoc[2](Arg2: u128)
Pack[1](PositionClosedEvent)
Call event::emit<PositionClosedEvent>(PositionClosedEvent)
Ret
}
public(friend) verify_collat_checks(Arg0: &Position, Arg1: &Position, Arg2: u128, Arg3: u128, Arg4: u128, Arg5: u8, Arg6: u64) {
L7:	loc0: bool
L8:	loc1: bool
L9:	loc2: bool
L10:	loc3: bool
L11:	loc4: S128
L12:	loc5: S128
B0:
CopyLoc[0](Arg0: &Position)
CopyLoc[4](Arg4: u128)
Call compute_margin_ratio(&Position, u128): S128
StLoc[12](loc5: S128)
CopyLoc[1](Arg1: &Position)
MoveLoc[4](Arg4: u128)
Call compute_margin_ratio(&Position, u128): S128
StLoc[11](loc4: S128)
CopyLoc[11](loc4: S128)
MoveLoc[2](Arg2: u128)
Call s128::gte_u128(S128, u128): bool
BrFalse(17)
B1:
MoveLoc[0](Arg0: &Position)
Pop
MoveLoc[1](Arg1: &Position)
Pop
Ret
B2:
CopyLoc[1](Arg1: &Position)
ImmBorrowField[0](Position.is_long: bool)
ReadRef
CopyLoc[0](Arg0: &Position)
ImmBorrowField[0](Position.is_long: bool)
ReadRef
Eq
BrFalse(32)
B3:
CopyLoc[0](Arg0: &Position)
ImmBorrowField[1](Position.size: u128)
ReadRef
LdU128(0)
Gt
StLoc[7](loc0: bool)
Branch(34)
B4:
LdFalse
StLoc[7](loc0: bool)
B5:
MoveLoc[7](loc0: bool)
BrFalse(37)
B6:
Branch(45)
B7:
MoveLoc[0](Arg0: &Position)
Pop
MoveLoc[1](Arg1: &Position)
Pop
LdU64(400)
MoveLoc[6](Arg6: u64)
Add
Abort
B8:
CopyLoc[11](loc4: S128)
MoveLoc[12](loc5: S128)
Call s128::gte(S128, S128): bool
BrFalse(50)
B9:
Branch(58)
B10:
MoveLoc[0](Arg0: &Position)
Pop
MoveLoc[1](Arg1: &Position)
Pop
LdU64(402)
MoveLoc[6](Arg6: u64)
Add
Abort
B11:
CopyLoc[11](loc4: S128)
MoveLoc[3](Arg3: u128)
Call s128::gt_u128(S128, u128): bool
BrFalse(69)
B12:
MoveLoc[0](Arg0: &Position)
Pop
MoveLoc[1](Arg1: &Position)
Pop
LdTrue
StLoc[8](loc1: bool)
Branch(94)
B13:
CopyLoc[0](Arg0: &Position)
ImmBorrowField[1](Position.size: u128)
ReadRef
CopyLoc[1](Arg1: &Position)
ImmBorrowField[1](Position.size: u128)
ReadRef
Ge
BrFalse(86)
B14:
MoveLoc[0](Arg0: &Position)
ImmBorrowField[0](Position.is_long: bool)
ReadRef
MoveLoc[1](Arg1: &Position)
ImmBorrowField[0](Position.is_long: bool)
ReadRef
Eq
StLoc[9](loc2: bool)
Branch(92)
B15:
MoveLoc[0](Arg0: &Position)
Pop
MoveLoc[1](Arg1: &Position)
Pop
LdFalse
StLoc[9](loc2: bool)
B16:
MoveLoc[9](loc2: bool)
StLoc[8](loc1: bool)
B17:
MoveLoc[8](loc1: bool)
BrFalse(97)
B18:
Branch(101)
B19:
LdU64(404)
MoveLoc[6](Arg6: u64)
Add
Abort
B20:
MoveLoc[11](loc4: S128)
LdU128(0)
Call s128::gte_u128(S128, u128): bool
BrFalse(108)
B21:
LdTrue
StLoc[10](loc3: bool)
Branch(119)
B22:
CopyLoc[5](Arg5: u8)
LdU8(2)
Eq
BrFalse(115)
B23:
LdTrue
StLoc[10](loc3: bool)
Branch(119)
B24:
MoveLoc[5](Arg5: u8)
LdU8(3)
Eq
StLoc[10](loc3: bool)
B25:
MoveLoc[10](loc3: bool)
BrFalse(122)
B26:
Branch(126)
B27:
LdU64(406)
MoveLoc[6](Arg6: u64)
Add
Abort
B28:
Ret
}
public(friend) compute_pnl_per_unit(Arg0: &Position, Arg1: u128): S128 {
L2:	loc0: S128
L3:	loc1: u128
B0:
CopyLoc[0](Arg0: &Position)
Call compute_average_entry_price(&Position): u128
StLoc[3](loc1: u128)
MoveLoc[0](Arg0: &Position)
ImmBorrowField[0](Position.is_long: bool)
ReadRef
BrFalse(12)
B1:
MoveLoc[1](Arg1: u128)
MoveLoc[3](loc1: u128)
Call s128::from_subtraction(u128, u128): S128
StLoc[2](loc0: S128)
Branch(16)
B2:
MoveLoc[3](loc1: u128)
MoveLoc[1](Arg1: u128)
Call s128::from_subtraction(u128, u128): S128
StLoc[2](loc0: S128)
B3:
MoveLoc[2](loc0: S128)
Ret
}
public(friend) is_undercollat(Arg0: &Position, Arg1: u128, Arg2: u128): bool {
B0:
MoveLoc[0](Arg0: &Position)
MoveLoc[1](Arg1: u128)
Call compute_margin_ratio(&Position, u128): S128
MoveLoc[2](Arg2: u128)
Call s128::lt_u128(S128, u128): bool
Ret
}
public(friend) compute_bankruptcy_price(Arg0: &Position): u128 {
L1:	loc0: u128
B0:
CopyLoc[0](Arg0: &Position)
Call is_long(&Position): bool
BrFalse(13)
B1:
CopyLoc[0](Arg0: &Position)
Call oi_open(&Position): u128
CopyLoc[0](Arg0: &Position)
Call margin(&Position): u128
Sub
MoveLoc[0](Arg0: &Position)
Call size(&Position): u128
Call library::base_div(u128, u128): u128
StLoc[1](loc0: u128)
Branch(22)
B2:
CopyLoc[0](Arg0: &Position)
Call oi_open(&Position): u128
CopyLoc[0](Arg0: &Position)
Call margin(&Position): u128
Add
MoveLoc[0](Arg0: &Position)
Call size(&Position): u128
Call library::base_div(u128, u128): u128
StLoc[1](loc0: u128)
B3:
MoveLoc[1](loc0: u128)
Ret
}
public(friend) compute_funding_fee_per_unit(Arg0: &Position, Arg1: FundingIndex): S128 {
L2:	loc0: S128
B0:
CopyLoc[0](Arg0: &Position)
ImmBorrowField[0](Position.is_long: bool)
ReadRef
BrFalse(13)
B1:
MoveLoc[0](Arg0: &Position)
ImmBorrowField[6](Position.index: FundingIndex)
ReadRef
Call funding_rate::index_value(FundingIndex): S128
MoveLoc[1](Arg1: FundingIndex)
Call funding_rate::index_value(FundingIndex): S128
Call s128::sub(S128, S128): S128
StLoc[2](loc0: S128)
Branch(21)
B2:
MoveLoc[1](Arg1: FundingIndex)
Call funding_rate::index_value(FundingIndex): S128
MoveLoc[0](Arg0: &Position)
ImmBorrowField[6](Position.index: FundingIndex)
ReadRef
Call funding_rate::index_value(FundingIndex): S128
Call s128::sub(S128, S128): S128
StLoc[2](loc0: S128)
B3:
MoveLoc[2](loc0: S128)
Ret
}
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/price_feed.mvb413 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.price_feed {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 9041eddbe15edba576c8c0bd4237e07b19e2c17fb59b240658f96522261f10c4::library as 0library;
use 9041eddbe15edba576c8c0bd4237e07b19e2c17fb59b240658f96522261f10c4::unified_address;
use 0000000000000000000000000000000000000000000000000000000000000002::bcs;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
struct PriceInfo has copy, drop, store {
	perp_id: ID,
	price: u128,
	timestamp: u64
}
struct PriceFeed has key {
	id: UID,
	feeder: address,
	prices: VecMap<ID, PriceInfo>
}
struct PriceInfoUpdate has copy, drop {
	perp_id: ID,
	price: u128,
	timestamp: u64
}
struct PriceFeedUpdateEvent has copy, drop {
	updates: vector<PriceInfoUpdate>,
	updated_count: u64
}
public(friend) initialize(Arg0: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call new_for_migration(&mut TxContext): PriceFeed
	2: Call share_price_feed(PriceFeed)
	3: Ret
}
public(friend) new_for_migration(Arg0: &mut TxContext): PriceFeed {
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: LdConst[2](address: 0x00..)
	3: Call vec_map::empty<ID, PriceInfo>(): VecMap<ID, PriceInfo>
	4: Pack[1](PriceFeed)
	5: Ret
}
public(friend) share_price_feed(Arg0: PriceFeed) {
B0:
	0: MoveLoc[0](Arg0: PriceFeed)
	1: Call transfer::share_object<PriceFeed>(PriceFeed)
	2: Ret
}
public(friend) insert_price_info(Arg0: &mut PriceFeed, Arg1: ID, Arg2: u128, Arg3: u64) {
L4:	loc0: PriceInfo
B0:
	0: CopyLoc[1](Arg1: ID)
	1: MoveLoc[2](Arg2: u128)
	2: MoveLoc[3](Arg3: u64)
	3: Pack[0](PriceInfo)
	4: StLoc[4](loc0: PriceInfo)
	5: MoveLoc[0](Arg0: &mut PriceFeed)
	6: MutBorrowField[0](PriceFeed.prices: VecMap<ID, PriceInfo>)
	7: MoveLoc[1](Arg1: ID)
	8: MoveLoc[4](loc0: PriceInfo)
	9: Call vec_map::insert<ID, PriceInfo>(&mut VecMap<ID, PriceInfo>, ID, PriceInfo)
	10: Ret
}
public(friend) set_feeder(Arg0: &mut PriceFeed, Arg1: address) {
B0:
	0: CopyLoc[1](Arg1: address)
	1: LdConst[2](address: 0x00..)
	2: Neq
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut PriceFeed)
	6: Pop
	7: LdU64(105)
	8: Abort
B3:
	9: MoveLoc[1](Arg1: address)
	10: MoveLoc[0](Arg0: &mut PriceFeed)
	11: MutBorrowField[1](PriceFeed.feeder: address)
	12: WriteRef
	13: Ret
}
public feeder(Arg0: &PriceFeed): address {
B0:
	0: MoveLoc[0](Arg0: &PriceFeed)
	1: ImmBorrowField[1](PriceFeed.feeder: address)
	2: ReadRef
	3: Ret
}
public update_price_feed(Arg0: &mut PriceFeed, Arg1: &Clock, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>) {
L5:	loc0: bool
L6:	loc1: vector<u8>
L7:	loc2: vector<u8>
L8:	loc3: vector<u8>
L9:	loc4: address
L10:	loc5: u8
L11:	loc6: UnifiedAddress
B0:
	0: CopyLoc[0](Arg0: &mut PriceFeed)
	1: ImmBorrowField[1](PriceFeed.feeder: address)
	2: ReadRef
	3: StLoc[9](loc4: address)
	4: CopyLoc[9](loc4: address)
	5: LdConst[2](address: 0x00..)
	6: Neq
	7: BrFalse(9)
B1:
	8: Branch(15)
B2:
	9: MoveLoc[0](Arg0: &mut PriceFeed)
	10: Pop
	11: MoveLoc[1](Arg1: &Clock)
	12: Pop
	13: LdU64(910)
	14: Abort
B3:
	15: ImmBorrowLoc[3](Arg3: vector<u8>)
	16: Call 0library::signature_scheme(&vector<u8>): u8
	17: StLoc[10](loc5: u8)
	18: CopyLoc[10](loc5: u8)
	19: Call 0library::scheme_secp256k1(): u8
	20: Eq
	21: BrFalse(25)
B4:
	22: LdTrue
	23: StLoc[5](loc0: bool)
	24: Branch(29)
B5:
	25: MoveLoc[10](loc5: u8)
	26: Call 0library::scheme_ed25519(): u8
	27: Eq
	28: StLoc[5](loc0: bool)
B6:
	29: MoveLoc[5](loc0: bool)
	30: BrFalse(32)
B7:
	31: Branch(38)
B8:
	32: MoveLoc[0](Arg0: &mut PriceFeed)
	33: Pop
	34: MoveLoc[1](Arg1: &Clock)
	35: Pop
	36: LdU64(908)
	37: Abort
B9:
	38: MoveLoc[3](Arg3: vector<u8>)
	39: StLoc[8](loc3: vector<u8>)
	40: MoveLoc[4](Arg4: vector<u8>)
	41: StLoc[7](loc2: vector<u8>)
	42: CopyLoc[2](Arg2: vector<u8>)
	43: StLoc[6](loc1: vector<u8>)
	44: MoveLoc[8](loc3: vector<u8>)
	45: MoveLoc[7](loc2: vector<u8>)
	46: MoveLoc[6](loc1: vector<u8>)
	47: LdU64(908)
	48: Call 0library::recover_signer_address(vector<u8>, vector<u8>, vector<u8>, u64): UnifiedAddress
	49: StLoc[11](loc6: UnifiedAddress)
	50: ImmBorrowLoc[11](loc6: UnifiedAddress)
	51: Call unified_address::identifier(&UnifiedAddress): address
	52: MoveLoc[9](loc4: address)
	53: Eq
	54: BrFalse(56)
B10:
	55: Branch(62)
B11:
	56: MoveLoc[0](Arg0: &mut PriceFeed)
	57: Pop
	58: MoveLoc[1](Arg1: &Clock)
	59: Pop
	60: LdU64(908)
	61: Abort
B12:
	62: MoveLoc[0](Arg0: &mut PriceFeed)
	63: MoveLoc[1](Arg1: &Clock)
	64: MoveLoc[2](Arg2: vector<u8>)
	65: Call collect_price_updates(&mut PriceFeed, &Clock, vector<u8>): vector<PriceInfoUpdate>
	66: Call emit_price_feed_update_event(vector<PriceInfoUpdate>)
	67: Ret
}
emit_price_feed_update_event(Arg0: vector<PriceInfoUpdate>) {
L1:	loc0: u64
B0:
	0: ImmBorrowLoc[0](Arg0: vector<PriceInfoUpdate>)
	1: VecLen(27)
	2: StLoc[1](loc0: u64)
	3: MoveLoc[0](Arg0: vector<PriceInfoUpdate>)
	4: MoveLoc[1](loc0: u64)
	5: Pack[3](PriceFeedUpdateEvent)
	6: Call event::emit<PriceFeedUpdateEvent>(PriceFeedUpdateEvent)
	7: Ret
}
collect_price_updates(Arg0: &mut PriceFeed, Arg1: &Clock, Arg2: vector<u8>): vector<PriceInfoUpdate> {
L3:	loc0: u64
L4:	loc1: u64
L5:	loc2: &ID
L6:	loc3: u64
L7:	loc4: u64
L8:	loc5: u64
L9:	loc6: ID
L10:	loc7: u128
L11:	loc8: &mut PriceInfo
L12:	loc9: BCS
L13:	loc10: u16
L14:	loc11: u64
L15:	loc12: vector<PriceInfoUpdate>
B0:
	0: MoveLoc[1](Arg1: &Clock)
	1: Call clock::timestamp_ms(&Clock): u64
	2: StLoc[8](loc5: u64)
	3: CopyLoc[8](loc5: u64)
	4: LdConst[1](u64: 5000)
	5: Add
	6: StLoc[4](loc1: u64)
	7: MoveLoc[2](Arg2: vector<u8>)
	8: Call bcs::new(vector<u8>): BCS
	9: StLoc[12](loc9: BCS)
	10: MutBorrowLoc[12](loc9: BCS)
	11: Call bcs::peel_vec_length(&mut BCS): u64
	12: StLoc[7](loc4: u64)
	13: CopyLoc[7](loc4: u64)
	14: LdU64(0)
	15: Gt
	16: BrFalse(18)
B1:
	17: Branch(22)
B2:
	18: MoveLoc[0](Arg0: &mut PriceFeed)
	19: Pop
	20: LdU64(909)
	21: Abort
B3:
	22: VecPack(27, 0)
	23: StLoc[15](loc12: vector<PriceInfoUpdate>)
	24: LdU64(0)
	25: StLoc[6](loc3: u64)
B4:
	26: CopyLoc[6](loc3: u64)
	27: CopyLoc[7](loc4: u64)
	28: Lt
	29: BrFalse(120)
B5:
	30: MutBorrowLoc[12](loc9: BCS)
	31: Call bcs::peel_address(&mut BCS): address
	32: Call object::id_from_address(address): ID
	33: StLoc[9](loc6: ID)
	34: MutBorrowLoc[12](loc9: BCS)
	35: Call bcs::peel_u128(&mut BCS): u128
	36: Call library::base_uint(): u128
	37: Div
	38: StLoc[10](loc7: u128)
	39: MutBorrowLoc[12](loc9: BCS)
	40: Call bcs::peel_u64(&mut BCS): u64
	41: StLoc[14](loc11: u64)
	42: CopyLoc[14](loc11: u64)
	43: CopyLoc[4](loc1: u64)
	44: Le
	45: BrFalse(47)
B6:
	46: Branch(51)
B7:
	47: MoveLoc[0](Arg0: &mut PriceFeed)
	48: Pop
	49: LdU64(912)
	50: Abort
B8:
	51: CopyLoc[14](loc11: u64)
	52: CopyLoc[8](loc5: u64)
	53: Gt
	54: BrFalse(58)
B9:
	55: LdU64(0)
	56: StLoc[3](loc0: u64)
	57: Branch(62)
B10:
	58: CopyLoc[8](loc5: u64)
	59: CopyLoc[14](loc11: u64)
	60: Sub
	61: StLoc[3](loc0: u64)
B11:
	62: MoveLoc[3](loc0: u64)
	63: LdConst[0](u64: 60000)
	64: Le
	65: BrFalse(67)
B12:
	66: Branch(71)
B13:
	67: MoveLoc[0](Arg0: &mut PriceFeed)
	68: Pop
	69: LdU64(913)
	70: Abort
B14:
	71: MutBorrowLoc[12](loc9: BCS)
	72: Call bcs::peel_u16(&mut BCS): u16
	73: StLoc[13](loc10: u16)
	74: CopyLoc[0](Arg0: &mut PriceFeed)
	75: MutBorrowField[0](PriceFeed.prices: VecMap<ID, PriceInfo>)
	76: MoveLoc[13](loc10: u16)
	77: CastU64
	78: Call vec_map::get_entry_by_idx_mut<ID, PriceInfo>(&mut VecMap<ID, PriceInfo>, u64): &ID * &mut PriceInfo
	79: StLoc[11](loc8: &mut PriceInfo)
	80: StLoc[5](loc2: &ID)
	81: ImmBorrowLoc[9](loc6: ID)
	82: MoveLoc[5](loc2: &ID)
	83: Eq
	84: BrFalse(86)
B15:
	85: Branch(92)
B16:
	86: MoveLoc[11](loc8: &mut PriceInfo)
	87: Pop
	88: MoveLoc[0](Arg0: &mut PriceFeed)
	89: Pop
	90: LdU64(914)
	91: Abort
B17:
	92: CopyLoc[14](loc11: u64)
	93: CopyLoc[11](loc8: &mut PriceInfo)
	94: ImmBorrowField[2](PriceInfo.timestamp: u64)
	95: ReadRef
	96: Ge
	97: BrFalse(113)
B18:
	98: CopyLoc[10](loc7: u128)
	99: CopyLoc[11](loc8: &mut PriceInfo)
	100: MutBorrowField[3](PriceInfo.price: u128)
	101: WriteRef
	102: CopyLoc[14](loc11: u64)
	103: MoveLoc[11](loc8: &mut PriceInfo)
	104: MutBorrowField[2](PriceInfo.timestamp: u64)
	105: WriteRef
	106: MutBorrowLoc[15](loc12: vector<PriceInfoUpdate>)
	107: MoveLoc[9](loc6: ID)
	108: MoveLoc[10](loc7: u128)
	109: MoveLoc[14](loc11: u64)
	110: Pack[2](PriceInfoUpdate)
	111: VecPushBack(27)
	112: Branch(115)
B19:
	113: MoveLoc[11](loc8: &mut PriceInfo)
	114: Pop
B20:
	115: MoveLoc[6](loc3: u64)
	116: LdU64(1)
	117: Add
	118: StLoc[6](loc3: u64)
	119: Branch(26)
B21:
	120: MoveLoc[0](Arg0: &mut PriceFeed)
	121: Pop
	122: MoveLoc[15](loc12: vector<PriceInfoUpdate>)
	123: Ret
}
public(friend) get_price_info(Arg0: &PriceFeed, Arg1: &ID): &PriceInfo {
B0:
	0: MoveLoc[0](Arg0: &PriceFeed)
	1: ImmBorrowField[0](PriceFeed.prices: VecMap<ID, PriceInfo>)
	2: MoveLoc[1](Arg1: &ID)
	3: Call vec_map::get<ID, PriceInfo>(&VecMap<ID, PriceInfo>, &ID): &PriceInfo
	4: Ret
}
public(friend) contains(Arg0: &PriceFeed, Arg1: &ID): bool {
B0:
	0: MoveLoc[0](Arg0: &PriceFeed)
	1: ImmBorrowField[0](PriceFeed.prices: VecMap<ID, PriceInfo>)
	2: MoveLoc[1](Arg1: &ID)
	3: Call vec_map::contains<ID, PriceInfo>(&VecMap<ID, PriceInfo>, &ID): bool
	4: Ret
}
public(friend) price_info_price(Arg0: &PriceInfo): u128 {
B0:
	0: MoveLoc[0](Arg0: &PriceInfo)
	1: ImmBorrowField[3](PriceInfo.price: u128)
	2: ReadRef
	3: Ret
}
public(friend) price_info_timestamp(Arg0: &PriceInfo): u64 {
B0:
	0: MoveLoc[0](Arg0: &PriceInfo)
	1: ImmBorrowField[2](PriceInfo.timestamp: u64)
	2: ReadRef
	3: Ret
}
Constants [
	0 => u64: 60000
	1 => u64: 5000
	2 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/protocol.mvb653 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.protocol {
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct ProtocolConfig has key {
	id: UID,
	version: u64,
	is_paused: bool,
	manager_cap_id: ID,
	deleveraging_cap_id: ID,
	funding_rate_cap_id: ID,
	settlement_cap_ids: VecSet<ID>,
	maker_gas_fee: u128,
	taker_gas_fee: u128,
	privileged_addresses: VecSet<address>
}
struct PerpetualRegistry has store {
	perpetuals: VecSet<ID>
}
struct GasConfig has store {
	relayer: address,
	gas_table: VecMap<String, u128>
}
struct SettlementOperatorAddresses has store {
	addresses: VecSet<address>
}
public(friend) initialize(Arg0: ID, Arg1: ID, Arg2: ID, Arg3: ID, Arg4: &mut TxContext) {
L5:	loc0: ProtocolConfig
B0:
	0: MoveLoc[4](Arg4: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: LdConst[0](u64: 6)
	3: LdFalse
	4: MoveLoc[0](Arg0: ID)
	5: MoveLoc[1](Arg1: ID)
	6: MoveLoc[2](Arg2: ID)
	7: Call vec_set::empty<ID>(): VecSet<ID>
	8: LdU128(0)
	9: LdU128(0)
	10: Call vec_set::empty<address>(): VecSet<address>
	11: Pack[0](ProtocolConfig)
	12: StLoc[5](loc0: ProtocolConfig)
	13: MutBorrowLoc[5](loc0: ProtocolConfig)
	14: MoveLoc[3](Arg3: ID)
	15: Call set_insurance_operator_cap_id(&mut ProtocolConfig, ID)
	16: MutBorrowLoc[5](loc0: ProtocolConfig)
	17: Call init_gas_config(&mut ProtocolConfig)
	18: MoveLoc[5](loc0: ProtocolConfig)
	19: Call transfer::share_object<ProtocolConfig>(ProtocolConfig)
	20: Ret
}
public(friend) version(): u64 {
B0:
	0: LdConst[0](u64: 6)
	1: Ret
}
public(friend) check_version(Arg0: &ProtocolConfig) {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[0](ProtocolConfig.version: u64)
	2: ReadRef
	3: LdConst[0](u64: 6)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(9)
B2:
	7: LdU64(3000)
	8: Abort
B3:
	9: Ret
}
public(friend) upgrade(Arg0: &mut ProtocolConfig) {
B0:
	0: CopyLoc[0](Arg0: &mut ProtocolConfig)
	1: ImmBorrowField[0](ProtocolConfig.version: u64)
	2: ReadRef
	3: LdU64(1)
	4: Add
	5: LdConst[0](u64: 6)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut ProtocolConfig)
	10: Pop
	11: LdU64(3000)
	12: Abort
B3:
	13: LdConst[0](u64: 6)
	14: MoveLoc[0](Arg0: &mut ProtocolConfig)
	15: MutBorrowField[0](ProtocolConfig.version: u64)
	16: WriteRef
	17: Ret
}
public(friend) check_basic(Arg0: &ProtocolConfig) {
B0:
	0: CopyLoc[0](Arg0: &ProtocolConfig)
	1: Call check_version(&ProtocolConfig)
	2: MoveLoc[0](Arg0: &ProtocolConfig)
	3: Call check_is_normal(&ProtocolConfig)
	4: Ret
}
public(friend) check_is_normal(Arg0: &ProtocolConfig) {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[1](ProtocolConfig.is_paused: bool)
	2: ReadRef
	3: Not
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdU64(100002)
	7: Abort
B3:
	8: Ret
}
public(friend) is_paused(Arg0: &ProtocolConfig): bool {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[1](ProtocolConfig.is_paused: bool)
	2: ReadRef
	3: Ret
}
public(friend) manager_cap_id(Arg0: &ProtocolConfig): ID {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[2](ProtocolConfig.manager_cap_id: ID)
	2: ReadRef
	3: Ret
}
public(friend) deleveraging_cap_id(Arg0: &ProtocolConfig): ID {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[3](ProtocolConfig.deleveraging_cap_id: ID)
	2: ReadRef
	3: Ret
}
public(friend) funding_rate_cap_id(Arg0: &ProtocolConfig): ID {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[4](ProtocolConfig.funding_rate_cap_id: ID)
	2: ReadRef
	3: Ret
}
public(friend) settlement_cap_ids(Arg0: &ProtocolConfig): &VecSet<ID> {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[5](ProtocolConfig.settlement_cap_ids: VecSet<ID>)
	2: Ret
}
public(friend) insurance_operator_cap_id(Arg0: &ProtocolConfig): ID {
B0:
	0: CopyLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[2](vector<u8>: "ins..)
	3: Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
	4: Not
	5: BrFalse(10)
B1:
	6: MoveLoc[0](Arg0: &ProtocolConfig)
	7: Pop
	8: LdU64(119)
	9: Abort
B2:
	10: MoveLoc[0](Arg0: &ProtocolConfig)
	11: ImmBorrowField[6](ProtocolConfig.id: UID)
	12: LdConst[2](vector<u8>: "ins..)
	13: Call dynamic_field::borrow<vector<u8>, ID>(&UID, vector<u8>): &ID
	14: ReadRef
	15: Ret
}
public(friend) set_is_paused(Arg0: &mut ProtocolConfig, Arg1: bool) {
B0:
	0: MoveLoc[1](Arg1: bool)
	1: MoveLoc[0](Arg0: &mut ProtocolConfig)
	2: MutBorrowField[1](ProtocolConfig.is_paused: bool)
	3: WriteRef
	4: Ret
}
public(friend) set_manager_cap_id(Arg0: &mut ProtocolConfig, Arg1: ID) {
B0:
	0: MoveLoc[1](Arg1: ID)
	1: MoveLoc[0](Arg0: &mut ProtocolConfig)
	2: MutBorrowField[2](ProtocolConfig.manager_cap_id: ID)
	3: WriteRef
	4: Ret
}
public(friend) set_deleveraging_cap_id(Arg0: &mut ProtocolConfig, Arg1: ID) {
B0:
	0: MoveLoc[1](Arg1: ID)
	1: MoveLoc[0](Arg0: &mut ProtocolConfig)
	2: MutBorrowField[3](ProtocolConfig.deleveraging_cap_id: ID)
	3: WriteRef
	4: Ret
}
public(friend) set_funding_rate_cap_id(Arg0: &mut ProtocolConfig, Arg1: ID) {
B0:
	0: MoveLoc[1](Arg1: ID)
	1: MoveLoc[0](Arg0: &mut ProtocolConfig)
	2: MutBorrowField[4](ProtocolConfig.funding_rate_cap_id: ID)
	3: WriteRef
	4: Ret
}
public(friend) set_insurance_operator_cap_id(Arg0: &mut ProtocolConfig, Arg1: ID) {
L2:	loc0: &mut ID
B0:
	0: CopyLoc[0](Arg0: &mut ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[2](vector<u8>: "ins..)
	3: Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
	4: Not
	5: BrFalse(12)
B1:
	6: MoveLoc[0](Arg0: &mut ProtocolConfig)
	7: MutBorrowField[6](ProtocolConfig.id: UID)
	8: LdConst[2](vector<u8>: "ins..)
	9: MoveLoc[1](Arg1: ID)
	10: Call dynamic_field::add<vector<u8>, ID>(&mut UID, vector<u8>, ID)
	11: Branch(20)
B2:
	12: MoveLoc[0](Arg0: &mut ProtocolConfig)
	13: MutBorrowField[6](ProtocolConfig.id: UID)
	14: LdConst[2](vector<u8>: "ins..)
	15: Call dynamic_field::borrow_mut<vector<u8>, ID>(&mut UID, vector<u8>): &mut ID
	16: StLoc[2](loc0: &mut ID)
	17: MoveLoc[1](Arg1: ID)
	18: MoveLoc[2](loc0: &mut ID)
	19: WriteRef
B3:
	20: Ret
}
public(friend) init_gas_config(Arg0: &mut ProtocolConfig) {
B0:
	0: CopyLoc[0](Arg0: &mut ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[3](vector<u8>: "gas..)
	3: Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
	4: Not
	5: BrFalse(14)
B1:
	6: MoveLoc[0](Arg0: &mut ProtocolConfig)
	7: MutBorrowField[6](ProtocolConfig.id: UID)
	8: LdConst[3](vector<u8>: "gas..)
	9: LdConst[5](address: 0x00..)
	10: Call vec_map::empty<String, u128>(): VecMap<String, u128>
	11: Pack[2](GasConfig)
	12: Call dynamic_field::add<vector<u8>, GasConfig>(&mut UID, vector<u8>, GasConfig)
	13: Branch(16)
B2:
	14: MoveLoc[0](Arg0: &mut ProtocolConfig)
	15: Pop
B3:
	16: Ret
}
public(friend) set_gas_relayer(Arg0: &mut ProtocolConfig, Arg1: address) {
L2:	loc0: &mut GasConfig
B0:
	0: CopyLoc[0](Arg0: &mut ProtocolConfig)
	1: Call init_gas_config(&mut ProtocolConfig)
	2: MoveLoc[0](Arg0: &mut ProtocolConfig)
	3: MutBorrowField[6](ProtocolConfig.id: UID)
	4: LdConst[3](vector<u8>: "gas..)
	5: Call dynamic_field::borrow_mut<vector<u8>, GasConfig>(&mut UID, vector<u8>): &mut GasConfig
	6: StLoc[2](loc0: &mut GasConfig)
	7: MoveLoc[1](Arg1: address)
	8: MoveLoc[2](loc0: &mut GasConfig)
	9: MutBorrowField[7](GasConfig.relayer: address)
	10: WriteRef
	11: Ret
}
public(friend) set_action_gas_fee(Arg0: &mut ProtocolConfig, Arg1: String, Arg2: u128) {
L3:	loc0: &mut GasConfig
B0:
	0: CopyLoc[0](Arg0: &mut ProtocolConfig)
	1: Call init_gas_config(&mut ProtocolConfig)
	2: MoveLoc[0](Arg0: &mut ProtocolConfig)
	3: MutBorrowField[6](ProtocolConfig.id: UID)
	4: LdConst[3](vector<u8>: "gas..)
	5: Call dynamic_field::borrow_mut<vector<u8>, GasConfig>(&mut UID, vector<u8>): &mut GasConfig
	6: StLoc[3](loc0: &mut GasConfig)
	7: CopyLoc[3](loc0: &mut GasConfig)
	8: ImmBorrowField[8](GasConfig.gas_table: VecMap<String, u128>)
	9: ImmBorrowLoc[1](Arg1: String)
	10: Call vec_map::contains<String, u128>(&VecMap<String, u128>, &String): bool
	11: BrFalse(19)
B1:
	12: MoveLoc[2](Arg2: u128)
	13: MoveLoc[3](loc0: &mut GasConfig)
	14: MutBorrowField[8](GasConfig.gas_table: VecMap<String, u128>)
	15: ImmBorrowLoc[1](Arg1: String)
	16: Call vec_map::get_mut<String, u128>(&mut VecMap<String, u128>, &String): &mut u128
	17: WriteRef
	18: Branch(24)
B2:
	19: MoveLoc[3](loc0: &mut GasConfig)
	20: MutBorrowField[8](GasConfig.gas_table: VecMap<String, u128>)
	21: MoveLoc[1](Arg1: String)
	22: MoveLoc[2](Arg2: u128)
	23: Call vec_map::insert<String, u128>(&mut VecMap<String, u128>, String, u128)
B3:
	24: Ret
}
public(friend) gas_relayer(Arg0: &ProtocolConfig): address {
B0:
	0: CopyLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[3](vector<u8>: "gas..)
	3: Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
	4: Not
	5: BrFalse(10)
B1:
	6: MoveLoc[0](Arg0: &ProtocolConfig)
	7: Pop
	8: LdConst[5](address: 0x00..)
	9: Ret
B2:
	10: MoveLoc[0](Arg0: &ProtocolConfig)
	11: ImmBorrowField[6](ProtocolConfig.id: UID)
	12: LdConst[3](vector<u8>: "gas..)
	13: Call dynamic_field::borrow<vector<u8>, GasConfig>(&UID, vector<u8>): &GasConfig
	14: ImmBorrowField[7](GasConfig.relayer: address)
	15: ReadRef
	16: Ret
}
public get_action_gas_fee(Arg0: &ProtocolConfig, Arg1: String, Arg2: &TxContext): u128 {
L3:	loc0: bool
L4:	loc1: &GasConfig
B0:
	0: CopyLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[3](vector<u8>: "gas..)
	3: Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
	4: Not
	5: BrFalse(12)
B1:
	6: MoveLoc[2](Arg2: &TxContext)
	7: Pop
	8: MoveLoc[0](Arg0: &ProtocolConfig)
	9: Pop
	10: LdU128(0)
	11: Ret
B2:
	12: MoveLoc[0](Arg0: &ProtocolConfig)
	13: ImmBorrowField[6](ProtocolConfig.id: UID)
	14: LdConst[3](vector<u8>: "gas..)
	15: Call dynamic_field::borrow<vector<u8>, GasConfig>(&UID, vector<u8>): &GasConfig
	16: StLoc[4](loc1: &GasConfig)
	17: MoveLoc[2](Arg2: &TxContext)
	18: Call tx_context::sender(&TxContext): address
	19: CopyLoc[4](loc1: &GasConfig)
	20: ImmBorrowField[7](GasConfig.relayer: address)
	21: ReadRef
	22: Neq
	23: BrFalse(27)
B3:
	24: LdTrue
	25: StLoc[3](loc0: bool)
	26: Branch(33)
B4:
	27: CopyLoc[4](loc1: &GasConfig)
	28: ImmBorrowField[8](GasConfig.gas_table: VecMap<String, u128>)
	29: ImmBorrowLoc[1](Arg1: String)
	30: Call vec_map::contains<String, u128>(&VecMap<String, u128>, &String): bool
	31: Not
	32: StLoc[3](loc0: bool)
B5:
	33: MoveLoc[3](loc0: bool)
	34: BrFalse(39)
B6:
	35: MoveLoc[4](loc1: &GasConfig)
	36: Pop
	37: LdU128(0)
	38: Ret
B7:
	39: MoveLoc[4](loc1: &GasConfig)
	40: ImmBorrowField[8](GasConfig.gas_table: VecMap<String, u128>)
	41: ImmBorrowLoc[1](Arg1: String)
	42: Call vec_map::get<String, u128>(&VecMap<String, u128>, &String): &u128
	43: ReadRef
	44: Ret
}
public(friend) configured_action_gas_fee(Arg0: &ProtocolConfig, Arg1: String): u128 {
L2:	loc0: &GasConfig
B0:
	0: CopyLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[3](vector<u8>: "gas..)
	3: Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
	4: Not
	5: BrFalse(10)
B1:
	6: MoveLoc[0](Arg0: &ProtocolConfig)
	7: Pop
	8: LdU128(0)
	9: Ret
B2:
	10: MoveLoc[0](Arg0: &ProtocolConfig)
	11: ImmBorrowField[6](ProtocolConfig.id: UID)
	12: LdConst[3](vector<u8>: "gas..)
	13: Call dynamic_field::borrow<vector<u8>, GasConfig>(&UID, vector<u8>): &GasConfig
	14: StLoc[2](loc0: &GasConfig)
	15: CopyLoc[2](loc0: &GasConfig)
	16: ImmBorrowField[8](GasConfig.gas_table: VecMap<String, u128>)
	17: ImmBorrowLoc[1](Arg1: String)
	18: Call vec_map::contains<String, u128>(&VecMap<String, u128>, &String): bool
	19: Not
	20: BrFalse(25)
B3:
	21: MoveLoc[2](loc0: &GasConfig)
	22: Pop
	23: LdU128(0)
	24: Ret
B4:
	25: MoveLoc[2](loc0: &GasConfig)
	26: ImmBorrowField[8](GasConfig.gas_table: VecMap<String, u128>)
	27: ImmBorrowLoc[1](Arg1: String)
	28: Call vec_map::get<String, u128>(&VecMap<String, u128>, &String): &u128
	29: ReadRef
	30: Ret
}
public(friend) clear_settlement_cap_ids(Arg0: &mut ProtocolConfig) {
B0:
	0: Call vec_set::empty<ID>(): VecSet<ID>
	1: MoveLoc[0](Arg0: &mut ProtocolConfig)
	2: MutBorrowField[5](ProtocolConfig.settlement_cap_ids: VecSet<ID>)
	3: WriteRef
	4: Ret
}
public(friend) init_settlement_operator_addresses(Arg0: &mut ProtocolConfig) {
B0:
	0: CopyLoc[0](Arg0: &mut ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[4](vector<u8>: "set..)
	3: Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
	4: Not
	5: BrFalse(13)
B1:
	6: MoveLoc[0](Arg0: &mut ProtocolConfig)
	7: MutBorrowField[6](ProtocolConfig.id: UID)
	8: LdConst[4](vector<u8>: "set..)
	9: Call vec_set::empty<address>(): VecSet<address>
	10: Pack[3](SettlementOperatorAddresses)
	11: Call dynamic_field::add<vector<u8>, SettlementOperatorAddresses>(&mut UID, vector<u8>, SettlementOperatorAddresses)
	12: Branch(15)
B2:
	13: MoveLoc[0](Arg0: &mut ProtocolConfig)
	14: Pop
B3:
	15: Ret
}
public(friend) settlement_operator_address_exists(Arg0: &ProtocolConfig, Arg1: address): bool {
B0:
	0: CopyLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[4](vector<u8>: "set..)
	3: Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
	4: Not
	5: BrFalse(10)
B1:
	6: MoveLoc[0](Arg0: &ProtocolConfig)
	7: Pop
	8: LdFalse
	9: Ret
B2:
	10: MoveLoc[0](Arg0: &ProtocolConfig)
	11: ImmBorrowField[6](ProtocolConfig.id: UID)
	12: LdConst[4](vector<u8>: "set..)
	13: Call dynamic_field::borrow<vector<u8>, SettlementOperatorAddresses>(&UID, vector<u8>): &SettlementOperatorAddresses
	14: ImmBorrowField[9](SettlementOperatorAddresses.addresses: VecSet<address>)
	15: ImmBorrowLoc[1](Arg1: address)
	16: Call vec_set::contains<address>(&VecSet<address>, &address): bool
	17: Ret
}
public(friend) add_settlement_operator_address(Arg0: &mut ProtocolConfig, Arg1: address) {
B0:
	0: CopyLoc[0](Arg0: &mut ProtocolConfig)
	1: Call init_settlement_operator_addresses(&mut ProtocolConfig)
	2: MoveLoc[0](Arg0: &mut ProtocolConfig)
	3: MutBorrowField[6](ProtocolConfig.id: UID)
	4: LdConst[4](vector<u8>: "set..)
	5: Call dynamic_field::borrow_mut<vector<u8>, SettlementOperatorAddresses>(&mut UID, vector<u8>): &mut SettlementOperatorAddresses
	6: MutBorrowField[9](SettlementOperatorAddresses.addresses: VecSet<address>)
	7: MoveLoc[1](Arg1: address)
	8: Call vec_set::insert<address>(&mut VecSet<address>, address)
	9: Ret
}
public(friend) remove_settlement_operator_address(Arg0: &mut ProtocolConfig, Arg1: address) {
B0:
	0: CopyLoc[0](Arg0: &mut ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[4](vector<u8>: "set..)
	3: Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
	4: Not
	5: BrFalse(10)
B1:
	6: MoveLoc[0](Arg0: &mut ProtocolConfig)
	7: Pop
	8: LdU64(112)
	9: Abort
B2:
	10: MoveLoc[0](Arg0: &mut ProtocolConfig)
	11: MutBorrowField[6](ProtocolConfig.id: UID)
	12: LdConst[4](vector<u8>: "set..)
	13: Call dynamic_field::borrow_mut<vector<u8>, SettlementOperatorAddresses>(&mut UID, vector<u8>): &mut SettlementOperatorAddresses
	14: MutBorrowField[9](SettlementOperatorAddresses.addresses: VecSet<address>)
	15: ImmBorrowLoc[1](Arg1: address)
	16: Call vec_set::remove<address>(&mut VecSet<address>, &address)
	17: Ret
}
public(friend) maker_gas_fee(Arg0: &ProtocolConfig): u128 {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[10](ProtocolConfig.maker_gas_fee: u128)
	2: ReadRef
	3: Ret
}
public(friend) set_maker_gas_fee(Arg0: &mut ProtocolConfig, Arg1: u128) {
B0:
	0: MoveLoc[1](Arg1: u128)
	1: MoveLoc[0](Arg0: &mut ProtocolConfig)
	2: MutBorrowField[10](ProtocolConfig.maker_gas_fee: u128)
	3: WriteRef
	4: Ret
}
public(friend) taker_gas_fee(Arg0: &ProtocolConfig): u128 {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[11](ProtocolConfig.taker_gas_fee: u128)
	2: ReadRef
	3: Ret
}
public(friend) set_taker_gas_fee(Arg0: &mut ProtocolConfig, Arg1: u128) {
B0:
	0: MoveLoc[1](Arg1: u128)
	1: MoveLoc[0](Arg0: &mut ProtocolConfig)
	2: MutBorrowField[11](ProtocolConfig.taker_gas_fee: u128)
	3: WriteRef
	4: Ret
}
public(friend) privileged_addresses(Arg0: &ProtocolConfig): &VecSet<address> {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[12](ProtocolConfig.privileged_addresses: VecSet<address>)
	2: Ret
}
public(friend) privileged_addresses_mut(Arg0: &mut ProtocolConfig): &mut VecSet<address> {
B0:
	0: MoveLoc[0](Arg0: &mut ProtocolConfig)
	1: MutBorrowField[12](ProtocolConfig.privileged_addresses: VecSet<address>)
	2: Ret
}
public(friend) register_perpetual(Arg0: &mut ProtocolConfig, Arg1: ID) {
B0:
	0: CopyLoc[0](Arg0: &mut ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[1](vector<u8>: "per..)
	3: Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
	4: Not
	5: BrFalse(12)
B1:
	6: CopyLoc[0](Arg0: &mut ProtocolConfig)
	7: MutBorrowField[6](ProtocolConfig.id: UID)
	8: LdConst[1](vector<u8>: "per..)
	9: Call vec_set::empty<ID>(): VecSet<ID>
	10: Pack[1](PerpetualRegistry)
	11: Call dynamic_field::add<vector<u8>, PerpetualRegistry>(&mut UID, vector<u8>, PerpetualRegistry)
B2:
	12: MoveLoc[0](Arg0: &mut ProtocolConfig)
	13: MutBorrowField[6](ProtocolConfig.id: UID)
	14: LdConst[1](vector<u8>: "per..)
	15: Call dynamic_field::borrow_mut<vector<u8>, PerpetualRegistry>(&mut UID, vector<u8>): &mut PerpetualRegistry
	16: MutBorrowField[13](PerpetualRegistry.perpetuals: VecSet<ID>)
	17: MoveLoc[1](Arg1: ID)
	18: Call vec_set::insert<ID>(&mut VecSet<ID>, ID)
	19: Ret
}
public(friend) perpetual_registry_exists(Arg0: &ProtocolConfig): bool {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[1](vector<u8>: "per..)
	3: Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
	4: Ret
}
public(friend) borrow_perpetual_ids(Arg0: &ProtocolConfig): &VecSet<ID> {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: ImmBorrowField[6](ProtocolConfig.id: UID)
	2: LdConst[1](vector<u8>: "per..)
	3: Call dynamic_field::borrow<vector<u8>, PerpetualRegistry>(&UID, vector<u8>): &PerpetualRegistry
	4: ImmBorrowField[13](PerpetualRegistry.perpetuals: VecSet<ID>)
	5: Ret
}
Constants [
	0 => u64: 6
	1 => vector<u8>: "perpetual_registry" // interpreted as UTF8 string
	2 => vector<u8>: "insurance_operator" // interpreted as UTF8 string
	3 => vector<u8>: "gas_config" // interpreted as UTF8 string
	4 => vector<u8>: "settlement_operator_addresses" // interpreted as UTF8 string
	5 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/roles.mvb823 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.roles {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::price_feed;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::protocol;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct ExchangeAdminUpdateEvent has copy, drop {
	account: address
}
struct ExchangeAdminPauseEvent has copy, drop {
	admin: address
}
struct ExchangeAdminResumeEvent has copy, drop {
	admin: address
}
struct ExchangeManagerUpdateEvent has copy, drop {
	id: ID,
	account: address
}
struct SettlementOperatorCreationEvent has copy, drop {
	id: ID,
	account: address
}
struct SettlementOperatorRemovalEvent has copy, drop {
	id: ID
}
struct SettlementOperatorAddressAddedEvent has copy, drop {
	account: address
}
struct SettlementOperatorAddressRemovedEvent has copy, drop {
	account: address
}
struct DelevergingOperatorUpdateEvent has copy, drop {
	id: ID,
	account: address
}
struct FundingRateOperatorUpdateEvent has copy, drop {
	id: ID,
	account: address
}
struct InsuranceOperatorUpdateEvent has copy, drop {
	id: ID,
	account: address
}
struct ExchangeAdminCap has key {
	id: UID
}
struct ExchangeManagerCap has key {
	id: UID
}
struct SettlementCap has key {
	id: UID
}
struct DeleveragingCap has key {
	id: UID
}
struct FundingRateCap has key {
	id: UID
}
struct InsuranceOperatorCap has key {
	id: UID
}
entry upgrade(Arg0: &ExchangeAdminCap, Arg1: &mut ProtocolConfig) {
B0:
	0: MoveLoc[1](Arg1: &mut ProtocolConfig)
	1: Call protocol::upgrade(&mut ProtocolConfig)
	2: Ret
}
entry pause(Arg0: &ExchangeAdminCap, Arg1: &mut ProtocolConfig, Arg2: &TxContext) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_version(&ProtocolConfig)
	3: CopyLoc[1](Arg1: &mut ProtocolConfig)
	4: FreezeRef
	5: Call protocol::is_paused(&ProtocolConfig): bool
	6: Not
	7: BrFalse(9)
B1:
	8: Branch(15)
B2:
	9: MoveLoc[2](Arg2: &TxContext)
	10: Pop
	11: MoveLoc[1](Arg1: &mut ProtocolConfig)
	12: Pop
	13: LdU64(100000)
	14: Abort
B3:
	15: MoveLoc[1](Arg1: &mut ProtocolConfig)
	16: LdTrue
	17: Call protocol::set_is_paused(&mut ProtocolConfig, bool)
	18: MoveLoc[2](Arg2: &TxContext)
	19: Call tx_context::sender(&TxContext): address
	20: Pack[1](ExchangeAdminPauseEvent)
	21: Call event::emit<ExchangeAdminPauseEvent>(ExchangeAdminPauseEvent)
	22: Ret
}
entry resume(Arg0: &ExchangeAdminCap, Arg1: &mut ProtocolConfig, Arg2: &TxContext) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_version(&ProtocolConfig)
	3: CopyLoc[1](Arg1: &mut ProtocolConfig)
	4: FreezeRef
	5: Call protocol::is_paused(&ProtocolConfig): bool
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[2](Arg2: &TxContext)
	9: Pop
	10: MoveLoc[1](Arg1: &mut ProtocolConfig)
	11: Pop
	12: LdU64(100001)
	13: Abort
B3:
	14: MoveLoc[1](Arg1: &mut ProtocolConfig)
	15: LdFalse
	16: Call protocol::set_is_paused(&mut ProtocolConfig, bool)
	17: MoveLoc[2](Arg2: &TxContext)
	18: Call tx_context::sender(&TxContext): address
	19: Pack[2](ExchangeAdminResumeEvent)
	20: Call event::emit<ExchangeAdminResumeEvent>(ExchangeAdminResumeEvent)
	21: Ret
}
entry set_exchange_admin(Arg0: ExchangeAdminCap, Arg1: address, Arg2: &TxContext) {
B0:
	0: CopyLoc[1](Arg1: address)
	1: LdConst[1](address: 0x00..)
	2: Neq
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[2](Arg2: &TxContext)
	6: Pop
	7: LdU64(105)
	8: Abort
B3:
	9: CopyLoc[1](Arg1: address)
	10: MoveLoc[2](Arg2: &TxContext)
	11: Call tx_context::sender(&TxContext): address
	12: Neq
	13: BrFalse(15)
B4:
	14: Branch(17)
B5:
	15: LdU64(900)
	16: Abort
B6:
	17: MoveLoc[0](Arg0: ExchangeAdminCap)
	18: CopyLoc[1](Arg1: address)
	19: Call transfer::transfer<ExchangeAdminCap>(ExchangeAdminCap, address)
	20: MoveLoc[1](Arg1: address)
	21: Pack[0](ExchangeAdminUpdateEvent)
	22: Call event::emit<ExchangeAdminUpdateEvent>(ExchangeAdminUpdateEvent)
	23: Ret
}
entry set_exchange_manager(Arg0: &ExchangeAdminCap, Arg1: &mut ProtocolConfig, Arg2: address, Arg3: &mut TxContext) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[2](Arg2: address)
	4: LdConst[1](address: 0x00..)
	5: Neq
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[3](Arg3: &mut TxContext)
	9: Pop
	10: MoveLoc[1](Arg1: &mut ProtocolConfig)
	11: Pop
	12: LdU64(105)
	13: Abort
B3:
	14: MoveLoc[1](Arg1: &mut ProtocolConfig)
	15: MoveLoc[2](Arg2: address)
	16: MoveLoc[3](Arg3: &mut TxContext)
	17: Call create_exchange_manager_cap(address, &mut TxContext): ID
	18: Call protocol::set_manager_cap_id(&mut ProtocolConfig, ID)
	19: Ret
}
entry set_deleveraging_operator(Arg0: &ExchangeAdminCap, Arg1: &mut ProtocolConfig, Arg2: address, Arg3: &mut TxContext) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[2](Arg2: address)
	4: LdConst[1](address: 0x00..)
	5: Neq
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[3](Arg3: &mut TxContext)
	9: Pop
	10: MoveLoc[1](Arg1: &mut ProtocolConfig)
	11: Pop
	12: LdU64(105)
	13: Abort
B3:
	14: MoveLoc[1](Arg1: &mut ProtocolConfig)
	15: MoveLoc[2](Arg2: address)
	16: MoveLoc[3](Arg3: &mut TxContext)
	17: Call create_deleveraging_cap(address, &mut TxContext): ID
	18: Call protocol::set_deleveraging_cap_id(&mut ProtocolConfig, ID)
	19: Ret
}
entry set_funding_rate_operator(Arg0: &ExchangeAdminCap, Arg1: &mut ProtocolConfig, Arg2: address, Arg3: &mut TxContext) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[2](Arg2: address)
	4: LdConst[1](address: 0x00..)
	5: Neq
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[3](Arg3: &mut TxContext)
	9: Pop
	10: MoveLoc[1](Arg1: &mut ProtocolConfig)
	11: Pop
	12: LdU64(105)
	13: Abort
B3:
	14: MoveLoc[1](Arg1: &mut ProtocolConfig)
	15: MoveLoc[2](Arg2: address)
	16: MoveLoc[3](Arg3: &mut TxContext)
	17: Call create_funding_rate_cap(address, &mut TxContext): ID
	18: Call protocol::set_funding_rate_cap_id(&mut ProtocolConfig, ID)
	19: Ret
}
entry set_insurance_operator(Arg0: &ExchangeAdminCap, Arg1: &mut ProtocolConfig, Arg2: address, Arg3: &mut TxContext) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[2](Arg2: address)
	4: LdConst[1](address: 0x00..)
	5: Neq
	6: BrFalse(8)
B1:
	7: Branch(14)
B2:
	8: MoveLoc[3](Arg3: &mut TxContext)
	9: Pop
	10: MoveLoc[1](Arg1: &mut ProtocolConfig)
	11: Pop
	12: LdU64(105)
	13: Abort
B3:
	14: MoveLoc[1](Arg1: &mut ProtocolConfig)
	15: MoveLoc[2](Arg2: address)
	16: MoveLoc[3](Arg3: &mut TxContext)
	17: Call create_insurance_operator_cap(address, &mut TxContext): ID
	18: Call protocol::set_insurance_operator_cap_id(&mut ProtocolConfig, ID)
	19: Ret
}
entry create_settlement_operator(Arg0: &ExchangeAdminCap, Arg1: &mut ProtocolConfig, Arg2: address, Arg3: &mut TxContext) {
B0:
	0: LdU64(999)
	1: Abort
}
public remove_settlement_operator(Arg0: &ExchangeAdminCap, Arg1: &mut ProtocolConfig, Arg2: ID) {
B0:
	0: LdU64(999)
	1: Abort
}
entry add_settlement_operator_address(Arg0: &ExchangeAdminCap, Arg1: &mut ProtocolConfig, Arg2: address) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[2](Arg2: address)
	4: LdConst[1](address: 0x00..)
	5: Neq
	6: BrFalse(8)
B1:
	7: Branch(12)
B2:
	8: MoveLoc[1](Arg1: &mut ProtocolConfig)
	9: Pop
	10: LdU64(105)
	11: Abort
B3:
	12: MoveLoc[1](Arg1: &mut ProtocolConfig)
	13: CopyLoc[2](Arg2: address)
	14: Call protocol::add_settlement_operator_address(&mut ProtocolConfig, address)
	15: MoveLoc[2](Arg2: address)
	16: Pack[6](SettlementOperatorAddressAddedEvent)
	17: Call event::emit<SettlementOperatorAddressAddedEvent>(SettlementOperatorAddressAddedEvent)
	18: Ret
}
entry remove_settlement_operator_address(Arg0: &ExchangeManagerCap, Arg1: &mut ProtocolConfig, Arg2: address) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[1](Arg1: &mut ProtocolConfig)
	4: FreezeRef
	5: MoveLoc[0](Arg0: &ExchangeManagerCap)
	6: Call check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
	7: MoveLoc[1](Arg1: &mut ProtocolConfig)
	8: CopyLoc[2](Arg2: address)
	9: Call protocol::remove_settlement_operator_address(&mut ProtocolConfig, address)
	10: MoveLoc[2](Arg2: address)
	11: Pack[7](SettlementOperatorAddressRemovedEvent)
	12: Call event::emit<SettlementOperatorAddressRemovedEvent>(SettlementOperatorAddressRemovedEvent)
	13: Ret
}
entry set_maker_gas_fee(Arg0: &ExchangeManagerCap, Arg1: &mut ProtocolConfig, Arg2: u128) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[1](Arg1: &mut ProtocolConfig)
	4: FreezeRef
	5: MoveLoc[0](Arg0: &ExchangeManagerCap)
	6: Call check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
	7: MoveLoc[2](Arg2: u128)
	8: Call library::base_uint(): u128
	9: Div
	10: StLoc[2](Arg2: u128)
	11: MoveLoc[1](Arg1: &mut ProtocolConfig)
	12: MoveLoc[2](Arg2: u128)
	13: Call protocol::set_maker_gas_fee(&mut ProtocolConfig, u128)
	14: Ret
}
entry set_taker_gas_fee(Arg0: &ExchangeManagerCap, Arg1: &mut ProtocolConfig, Arg2: u128) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[1](Arg1: &mut ProtocolConfig)
	4: FreezeRef
	5: MoveLoc[0](Arg0: &ExchangeManagerCap)
	6: Call check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
	7: MoveLoc[2](Arg2: u128)
	8: Call library::base_uint(): u128
	9: Div
	10: StLoc[2](Arg2: u128)
	11: MoveLoc[1](Arg1: &mut ProtocolConfig)
	12: MoveLoc[2](Arg2: u128)
	13: Call protocol::set_taker_gas_fee(&mut ProtocolConfig, u128)
	14: Ret
}
public(friend) set_gas_relayer(Arg0: &ExchangeManagerCap, Arg1: &mut ProtocolConfig, Arg2: address) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[1](Arg1: &mut ProtocolConfig)
	4: FreezeRef
	5: MoveLoc[0](Arg0: &ExchangeManagerCap)
	6: Call check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
	7: CopyLoc[2](Arg2: address)
	8: LdConst[1](address: 0x00..)
	9: Neq
	10: BrFalse(12)
B1:
	11: Branch(16)
B2:
	12: MoveLoc[1](Arg1: &mut ProtocolConfig)
	13: Pop
	14: LdU64(105)
	15: Abort
B3:
	16: MoveLoc[1](Arg1: &mut ProtocolConfig)
	17: MoveLoc[2](Arg2: address)
	18: Call protocol::set_gas_relayer(&mut ProtocolConfig, address)
	19: Ret
}
entry set_action_gas_fee(Arg0: &ExchangeManagerCap, Arg1: &mut ProtocolConfig, Arg2: String, Arg3: u128) {
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[1](Arg1: &mut ProtocolConfig)
	4: FreezeRef
	5: MoveLoc[0](Arg0: &ExchangeManagerCap)
	6: Call check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
	7: MoveLoc[3](Arg3: u128)
	8: Call library::base_uint(): u128
	9: Div
	10: StLoc[3](Arg3: u128)
	11: CopyLoc[3](Arg3: u128)
	12: LdConst[0](u128: 5000..)
	13: Le
	14: BrFalse(16)
B1:
	15: Branch(20)
B2:
	16: MoveLoc[1](Arg1: &mut ProtocolConfig)
	17: Pop
	18: LdU64(3001)
	19: Abort
B3:
	20: MoveLoc[1](Arg1: &mut ProtocolConfig)
	21: MoveLoc[2](Arg2: String)
	22: MoveLoc[3](Arg3: u128)
	23: Call protocol::set_action_gas_fee(&mut ProtocolConfig, String, u128)
	24: Ret
}
entry set_price_feeder(Arg0: &ExchangeManagerCap, Arg1: &ProtocolConfig, Arg2: &mut PriceFeed, Arg3: address) {
B0:
	0: CopyLoc[1](Arg1: &ProtocolConfig)
	1: Call protocol::check_basic(&ProtocolConfig)
	2: MoveLoc[1](Arg1: &ProtocolConfig)
	3: MoveLoc[0](Arg0: &ExchangeManagerCap)
	4: Call check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
	5: CopyLoc[3](Arg3: address)
	6: LdConst[1](address: 0x00..)
	7: Neq
	8: BrFalse(10)
B1:
	9: Branch(14)
B2:
	10: MoveLoc[2](Arg2: &mut PriceFeed)
	11: Pop
	12: LdU64(105)
	13: Abort
B3:
	14: MoveLoc[2](Arg2: &mut PriceFeed)
	15: MoveLoc[3](Arg3: address)
	16: Call price_feed::set_feeder(&mut PriceFeed, address)
	17: Ret
}
entry add_privileged_addresses(Arg0: &ExchangeManagerCap, Arg1: &mut ProtocolConfig, Arg2: vector<address>) {
L3:	loc0: address
L4:	loc1: u64
L5:	loc2: u64
L6:	loc3: &mut VecSet<address>
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[1](Arg1: &mut ProtocolConfig)
	4: FreezeRef
	5: MoveLoc[0](Arg0: &ExchangeManagerCap)
	6: Call check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
	7: ImmBorrowLoc[2](Arg2: vector<address>)
	8: VecLen(26)
	9: StLoc[5](loc2: u64)
	10: CopyLoc[5](loc2: u64)
	11: LdU64(0)
	12: Gt
	13: BrFalse(15)
B1:
	14: Branch(19)
B2:
	15: MoveLoc[1](Arg1: &mut ProtocolConfig)
	16: Pop
	17: LdU64(109)
	18: Abort
B3:
	19: LdU64(0)
	20: StLoc[4](loc1: u64)
	21: MoveLoc[1](Arg1: &mut ProtocolConfig)
	22: Call protocol::privileged_addresses_mut(&mut ProtocolConfig): &mut VecSet<address>
	23: StLoc[6](loc3: &mut VecSet<address>)
B4:
	24: CopyLoc[4](loc1: u64)
	25: CopyLoc[5](loc2: u64)
	26: Lt
	27: BrFalse(41)
B5:
	28: ImmBorrowLoc[2](Arg2: vector<address>)
	29: CopyLoc[4](loc1: u64)
	30: VecImmBorrow(26)
	31: ReadRef
	32: StLoc[3](loc0: address)
	33: CopyLoc[6](loc3: &mut VecSet<address>)
	34: MoveLoc[3](loc0: address)
	35: Call vec_set::insert<address>(&mut VecSet<address>, address)
	36: MoveLoc[4](loc1: u64)
	37: LdU64(1)
	38: Add
	39: StLoc[4](loc1: u64)
	40: Branch(24)
B6:
	41: MoveLoc[6](loc3: &mut VecSet<address>)
	42: Pop
	43: Ret
}
entry remove_privileged_addresses(Arg0: &ExchangeManagerCap, Arg1: &mut ProtocolConfig, Arg2: vector<address>) {
L3:	loc0: &address
L4:	loc1: u64
L5:	loc2: u64
L6:	loc3: &mut VecSet<address>
B0:
	0: CopyLoc[1](Arg1: &mut ProtocolConfig)
	1: FreezeRef
	2: Call protocol::check_basic(&ProtocolConfig)
	3: CopyLoc[1](Arg1: &mut ProtocolConfig)
	4: FreezeRef
	5: MoveLoc[0](Arg0: &ExchangeManagerCap)
	6: Call check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
	7: ImmBorrowLoc[2](Arg2: vector<address>)
	8: VecLen(26)
	9: StLoc[5](loc2: u64)
	10: CopyLoc[5](loc2: u64)
	11: LdU64(0)
	12: Gt
	13: BrFalse(15)
B1:
	14: Branch(19)
B2:
	15: MoveLoc[1](Arg1: &mut ProtocolConfig)
	16: Pop
	17: LdU64(109)
	18: Abort
B3:
	19: LdU64(0)
	20: StLoc[4](loc1: u64)
	21: MoveLoc[1](Arg1: &mut ProtocolConfig)
	22: Call protocol::privileged_addresses_mut(&mut ProtocolConfig): &mut VecSet<address>
	23: StLoc[6](loc3: &mut VecSet<address>)
B4:
	24: CopyLoc[4](loc1: u64)
	25: CopyLoc[5](loc2: u64)
	26: Lt
	27: BrFalse(40)
B5:
	28: ImmBorrowLoc[2](Arg2: vector<address>)
	29: CopyLoc[4](loc1: u64)
	30: VecImmBorrow(26)
	31: StLoc[3](loc0: &address)
	32: CopyLoc[6](loc3: &mut VecSet<address>)
	33: MoveLoc[3](loc0: &address)
	34: Call vec_set::remove<address>(&mut VecSet<address>, &address)
	35: MoveLoc[4](loc1: u64)
	36: LdU64(1)
	37: Add
	38: StLoc[4](loc1: u64)
	39: Branch(24)
B6:
	40: MoveLoc[6](loc3: &mut VecSet<address>)
	41: Pop
	42: Ret
}
public(friend) initialize(Arg0: &mut TxContext): ID * ID * ID * ID {
L1:	loc0: ID
L2:	loc1: ID
L3:	loc2: ID
L4:	loc3: ID
B0:
	0: CopyLoc[0](Arg0: &mut TxContext)
	1: Call create_exchange_admin_cap(&mut TxContext)
	2: CopyLoc[0](Arg0: &mut TxContext)
	3: FreezeRef
	4: Call tx_context::sender(&TxContext): address
	5: CopyLoc[0](Arg0: &mut TxContext)
	6: Call create_exchange_manager_cap(address, &mut TxContext): ID
	7: StLoc[4](loc3: ID)
	8: CopyLoc[0](Arg0: &mut TxContext)
	9: FreezeRef
	10: Call tx_context::sender(&TxContext): address
	11: CopyLoc[0](Arg0: &mut TxContext)
	12: Call create_deleveraging_cap(address, &mut TxContext): ID
	13: StLoc[1](loc0: ID)
	14: CopyLoc[0](Arg0: &mut TxContext)
	15: FreezeRef
	16: Call tx_context::sender(&TxContext): address
	17: CopyLoc[0](Arg0: &mut TxContext)
	18: Call create_funding_rate_cap(address, &mut TxContext): ID
	19: StLoc[2](loc1: ID)
	20: CopyLoc[0](Arg0: &mut TxContext)
	21: FreezeRef
	22: Call tx_context::sender(&TxContext): address
	23: MoveLoc[0](Arg0: &mut TxContext)
	24: Call create_insurance_operator_cap(address, &mut TxContext): ID
	25: StLoc[3](loc2: ID)
	26: MoveLoc[4](loc3: ID)
	27: MoveLoc[1](loc0: ID)
	28: MoveLoc[2](loc1: ID)
	29: MoveLoc[3](loc2: ID)
	30: Ret
}
public(friend) check_manager_validity(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap) {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: Call protocol::manager_cap_id(&ProtocolConfig): ID
	2: MoveLoc[1](Arg1: &ExchangeManagerCap)
	3: ImmBorrowField[0](ExchangeManagerCap.id: UID)
	4: Call object::uid_to_inner(&UID): ID
	5: Eq
	6: BrFalse(8)
B1:
	7: Branch(10)
B2:
	8: LdU64(111)
	9: Abort
B3:
	10: Ret
}
public(friend) check_deleveraging_operator_validity(Arg0: &ProtocolConfig, Arg1: &DeleveragingCap) {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: Call protocol::deleveraging_cap_id(&ProtocolConfig): ID
	2: MoveLoc[1](Arg1: &DeleveragingCap)
	3: ImmBorrowField[1](DeleveragingCap.id: UID)
	4: Call object::uid_to_inner(&UID): ID
	5: Eq
	6: BrFalse(8)
B1:
	7: Branch(10)
B2:
	8: LdU64(113)
	9: Abort
B3:
	10: Ret
}
public(friend) check_funding_rate_operator_validity(Arg0: &ProtocolConfig, Arg1: &FundingRateCap) {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: Call protocol::funding_rate_cap_id(&ProtocolConfig): ID
	2: MoveLoc[1](Arg1: &FundingRateCap)
	3: ImmBorrowField[2](FundingRateCap.id: UID)
	4: Call object::uid_to_inner(&UID): ID
	5: Eq
	6: BrFalse(8)
B1:
	7: Branch(10)
B2:
	8: LdU64(101)
	9: Abort
B3:
	10: Ret
}
public(friend) check_settlement_sender_validity(Arg0: &ProtocolConfig, Arg1: address) {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: MoveLoc[1](Arg1: address)
	2: Call protocol::settlement_operator_address_exists(&ProtocolConfig, address): bool
	3: BrFalse(5)
B1:
	4: Branch(7)
B2:
	5: LdU64(110)
	6: Abort
B3:
	7: Ret
}
public(friend) check_insurance_operator_validity(Arg0: &ProtocolConfig, Arg1: &InsuranceOperatorCap) {
B0:
	0: MoveLoc[0](Arg0: &ProtocolConfig)
	1: Call protocol::insurance_operator_cap_id(&ProtocolConfig): ID
	2: MoveLoc[1](Arg1: &InsuranceOperatorCap)
	3: ImmBorrowField[3](InsuranceOperatorCap.id: UID)
	4: Call object::uid_to_inner(&UID): ID
	5: Eq
	6: BrFalse(8)
B1:
	7: Branch(10)
B2:
	8: LdU64(119)
	9: Abort
B3:
	10: Ret
}
create_exchange_admin_cap(Arg0: &mut TxContext) {
B0:
	0: CopyLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: Pack[11](ExchangeAdminCap)
	3: CopyLoc[0](Arg0: &mut TxContext)
	4: FreezeRef
	5: Call tx_context::sender(&TxContext): address
	6: Call transfer::transfer<ExchangeAdminCap>(ExchangeAdminCap, address)
	7: MoveLoc[0](Arg0: &mut TxContext)
	8: FreezeRef
	9: Call tx_context::sender(&TxContext): address
	10: Pack[0](ExchangeAdminUpdateEvent)
	11: Call event::emit<ExchangeAdminUpdateEvent>(ExchangeAdminUpdateEvent)
	12: Ret
}
create_exchange_manager_cap(Arg0: address, Arg1: &mut TxContext): ID {
L2:	loc0: UID
L3:	loc1: ID
B0:
	0: MoveLoc[1](Arg1: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: StLoc[2](loc0: UID)
	3: ImmBorrowLoc[2](loc0: UID)
	4: Call object::uid_to_inner(&UID): ID
	5: StLoc[3](loc1: ID)
	6: MoveLoc[2](loc0: UID)
	7: Pack[12](ExchangeManagerCap)
	8: CopyLoc[0](Arg0: address)
	9: Call transfer::transfer<ExchangeManagerCap>(ExchangeManagerCap, address)
	10: CopyLoc[3](loc1: ID)
	11: MoveLoc[0](Arg0: address)
	12: Pack[3](ExchangeManagerUpdateEvent)
	13: Call event::emit<ExchangeManagerUpdateEvent>(ExchangeManagerUpdateEvent)
	14: MoveLoc[3](loc1: ID)
	15: Ret
}
create_deleveraging_cap(Arg0: address, Arg1: &mut TxContext): ID {
L2:	loc0: ID
L3:	loc1: UID
B0:
	0: MoveLoc[1](Arg1: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: StLoc[3](loc1: UID)
	3: ImmBorrowLoc[3](loc1: UID)
	4: Call object::uid_to_inner(&UID): ID
	5: StLoc[2](loc0: ID)
	6: MoveLoc[3](loc1: UID)
	7: Pack[14](DeleveragingCap)
	8: CopyLoc[0](Arg0: address)
	9: Call transfer::transfer<DeleveragingCap>(DeleveragingCap, address)
	10: CopyLoc[2](loc0: ID)
	11: MoveLoc[0](Arg0: address)
	12: Pack[8](DelevergingOperatorUpdateEvent)
	13: Call event::emit<DelevergingOperatorUpdateEvent>(DelevergingOperatorUpdateEvent)
	14: MoveLoc[2](loc0: ID)
	15: Ret
}
create_funding_rate_cap(Arg0: address, Arg1: &mut TxContext): ID {
L2:	loc0: ID
L3:	loc1: UID
B0:
	0: MoveLoc[1](Arg1: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: StLoc[3](loc1: UID)
	3: ImmBorrowLoc[3](loc1: UID)
	4: Call object::uid_to_inner(&UID): ID
	5: StLoc[2](loc0: ID)
	6: MoveLoc[3](loc1: UID)
	7: Pack[15](FundingRateCap)
	8: CopyLoc[0](Arg0: address)
	9: Call transfer::transfer<FundingRateCap>(FundingRateCap, address)
	10: CopyLoc[2](loc0: ID)
	11: MoveLoc[0](Arg0: address)
	12: Pack[9](FundingRateOperatorUpdateEvent)
	13: Call event::emit<FundingRateOperatorUpdateEvent>(FundingRateOperatorUpdateEvent)
	14: MoveLoc[2](loc0: ID)
	15: Ret
}
public(friend) create_insurance_operator_cap(Arg0: address, Arg1: &mut TxContext): ID {
L2:	loc0: UID
L3:	loc1: ID
B0:
	0: MoveLoc[1](Arg1: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: StLoc[2](loc0: UID)
	3: ImmBorrowLoc[2](loc0: UID)
	4: Call object::uid_to_inner(&UID): ID
	5: StLoc[3](loc1: ID)
	6: MoveLoc[2](loc0: UID)
	7: Pack[16](InsuranceOperatorCap)
	8: CopyLoc[0](Arg0: address)
	9: Call transfer::transfer<InsuranceOperatorCap>(InsuranceOperatorCap, address)
	10: CopyLoc[3](loc1: ID)
	11: MoveLoc[0](Arg0: address)
	12: Pack[10](InsuranceOperatorUpdateEvent)
	13: Call event::emit<InsuranceOperatorUpdateEvent>(InsuranceOperatorUpdateEvent)
	14: MoveLoc[3](loc1: ID)
	15: Ret
}
Constants [
	0 => u128: 500000000
	1 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/s128.mvb688 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.s128 {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
struct S128 has copy, drop, store {
	value: u128,
	sign: bool
}
public(friend) zero(): S128 {
B0:
LdU128(0)
LdTrue
Pack[0](S128)
Ret
}
public(friend) from(Arg0: u128, Arg1: bool): S128 {
L2:	loc0: S128
B0:
MoveLoc[0](Arg0: u128)
MoveLoc[1](Arg1: bool)
Pack[0](S128)
StLoc[2](loc0: S128)
MutBorrowLoc[2](loc0: S128)
Call normalize_zero(&mut S128)
MoveLoc[2](loc0: S128)
Ret
}
public(friend) one(): S128 {
B0:
Call library::base_uint(): u128
LdTrue
Pack[0](S128)
Ret
}
public(friend) add_u128(Arg0: S128, Arg1: u128): S128 {
L2:	loc0: bool
L3:	loc1: u128
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
StLoc[3](loc1: u128)
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
StLoc[2](loc0: bool)
CopyLoc[2](loc0: bool)
LdTrue
Eq
BrFalse(17)
B1:
MoveLoc[3](loc1: u128)
MoveLoc[1](Arg1: u128)
Add
StLoc[3](loc1: u128)
Branch(32)
B2:
CopyLoc[3](loc1: u128)
CopyLoc[1](Arg1: u128)
Gt
BrFalse(26)
B3:
MoveLoc[3](loc1: u128)
MoveLoc[1](Arg1: u128)
Sub
StLoc[3](loc1: u128)
Branch(32)
B4:
MoveLoc[1](Arg1: u128)
MoveLoc[3](loc1: u128)
Sub
StLoc[3](loc1: u128)
LdTrue
StLoc[2](loc0: bool)
B5:
MoveLoc[3](loc1: u128)
MoveLoc[2](loc0: bool)
Call from(u128, bool): S128
Ret
}
public(friend) sub_u128(Arg0: S128, Arg1: u128): S128 {
L2:	loc0: bool
L3:	loc1: u128
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
StLoc[3](loc1: u128)
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
StLoc[2](loc0: bool)
CopyLoc[2](loc0: bool)
LdFalse
Eq
BrFalse(17)
B1:
MoveLoc[3](loc1: u128)
MoveLoc[1](Arg1: u128)
Add
StLoc[3](loc1: u128)
Branch(32)
B2:
CopyLoc[3](loc1: u128)
CopyLoc[1](Arg1: u128)
Gt
BrFalse(26)
B3:
MoveLoc[3](loc1: u128)
MoveLoc[1](Arg1: u128)
Sub
StLoc[3](loc1: u128)
Branch(32)
B4:
MoveLoc[1](Arg1: u128)
MoveLoc[3](loc1: u128)
Sub
StLoc[3](loc1: u128)
LdFalse
StLoc[2](loc0: bool)
B5:
MoveLoc[3](loc1: u128)
MoveLoc[2](loc0: bool)
Call from(u128, bool): S128
Ret
}
public(friend) mul_u128(Arg0: S128, Arg1: u128): S128 {
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
MoveLoc[1](Arg1: u128)
Call library::base_mul(u128, u128): u128
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Call from(u128, bool): S128
Ret
}
public(friend) mul_u128_up(Arg0: S128, Arg1: u128): S128 {
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
MoveLoc[1](Arg1: u128)
Call library::base_mul_up(u128, u128): u128
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Call from(u128, bool): S128
Ret
}
public(friend) div_u128(Arg0: S128, Arg1: u128): S128 {
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
MoveLoc[1](Arg1: u128)
Call library::base_div(u128, u128): u128
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Call from(u128, bool): S128
Ret
}
public(friend) negate(Arg0: S128): S128 {
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
Call from(u128, bool): S128
Ret
}
public(friend) add(Arg0: S128, Arg1: S128): S128 {
L2:	loc0: bool
L3:	loc1: u128
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Eq
BrFalse(21)
B1:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Add
StLoc[3](loc1: u128)
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
StLoc[2](loc0: bool)
Branch(54)
B2:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Ge
BrFalse(42)
B3:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Sub
StLoc[3](loc1: u128)
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
StLoc[2](loc0: bool)
Branch(54)
B4:
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Sub
StLoc[3](loc1: u128)
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
StLoc[2](loc0: bool)
B5:
MoveLoc[3](loc1: u128)
MoveLoc[2](loc0: bool)
Call from(u128, bool): S128
Ret
}
public(friend) sub(Arg0: S128, Arg1: S128): S128 {
L2:	loc0: bool
L3:	loc1: u128
B0:
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
MutBorrowLoc[1](Arg1: S128)
MutBorrowField[1](S128.sign: bool)
WriteRef
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Eq
BrFalse(28)
B1:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Add
StLoc[3](loc1: u128)
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
StLoc[2](loc0: bool)
Branch(61)
B2:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Ge
BrFalse(49)
B3:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Sub
StLoc[3](loc1: u128)
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
StLoc[2](loc0: bool)
Branch(61)
B4:
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Sub
StLoc[3](loc1: u128)
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
StLoc[2](loc0: bool)
B5:
MoveLoc[3](loc1: u128)
MoveLoc[2](loc0: bool)
Call from(u128, bool): S128
Ret
}
public(friend) gte_u128(Arg0: S128, Arg1: u128): bool {
L2:	loc0: bool
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
BrFalse(8)
B1:
LdFalse
StLoc[2](loc0: bool)
Branch(14)
B2:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
MoveLoc[1](Arg1: u128)
Ge
StLoc[2](loc0: bool)
B3:
MoveLoc[2](loc0: bool)
Ret
}
public(friend) gt_u128(Arg0: S128, Arg1: u128): bool {
L2:	loc0: bool
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
BrFalse(8)
B1:
LdFalse
StLoc[2](loc0: bool)
Branch(14)
B2:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
MoveLoc[1](Arg1: u128)
Gt
StLoc[2](loc0: bool)
B3:
MoveLoc[2](loc0: bool)
Ret
}
public(friend) lt_u128(Arg0: S128, Arg1: u128): bool {
L2:	loc0: bool
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
BrFalse(8)
B1:
LdTrue
StLoc[2](loc0: bool)
Branch(14)
B2:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
MoveLoc[1](Arg1: u128)
Lt
StLoc[2](loc0: bool)
B3:
MoveLoc[2](loc0: bool)
Ret
}
public(friend) lte_u128(Arg0: S128, Arg1: u128): bool {
L2:	loc0: bool
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
BrFalse(8)
B1:
LdTrue
StLoc[2](loc0: bool)
Branch(14)
B2:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
MoveLoc[1](Arg1: u128)
Le
StLoc[2](loc0: bool)
B3:
MoveLoc[2](loc0: bool)
Ret
}
public(friend) gte(Arg0: S128, Arg1: S128): bool {
L2:	loc0: bool
L3:	loc1: bool
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
BrFalse(9)
B1:
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
StLoc[2](loc0: bool)
Branch(11)
B2:
LdFalse
StLoc[2](loc0: bool)
B3:
MoveLoc[2](loc0: bool)
BrFalse(21)
B4:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Ge
Ret
B5:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
BrFalse(32)
B6:
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
StLoc[3](loc1: bool)
Branch(34)
B7:
LdFalse
StLoc[3](loc1: bool)
B8:
MoveLoc[3](loc1: bool)
BrFalse(44)
B9:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Le
Ret
B10:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Ret
}
public(friend) gt(Arg0: S128, Arg1: S128): bool {
L2:	loc0: bool
L3:	loc1: bool
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
BrFalse(9)
B1:
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
StLoc[2](loc0: bool)
Branch(11)
B2:
LdFalse
StLoc[2](loc0: bool)
B3:
MoveLoc[2](loc0: bool)
BrFalse(21)
B4:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Gt
Ret
B5:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
BrFalse(32)
B6:
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
StLoc[3](loc1: bool)
Branch(34)
B7:
LdFalse
StLoc[3](loc1: bool)
B8:
MoveLoc[3](loc1: bool)
BrFalse(44)
B9:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
ImmBorrowLoc[1](Arg1: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Lt
Ret
B10:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Ret
}
public(friend) from_subtraction(Arg0: u128, Arg1: u128): S128 {
L2:	loc0: S128
B0:
CopyLoc[0](Arg0: u128)
CopyLoc[1](Arg1: u128)
Ge
BrFalse(11)
B1:
MoveLoc[0](Arg0: u128)
MoveLoc[1](Arg1: u128)
Sub
LdTrue
Pack[0](S128)
StLoc[2](loc0: S128)
Branch(17)
B2:
MoveLoc[1](Arg1: u128)
MoveLoc[0](Arg0: u128)
Sub
LdFalse
Pack[0](S128)
StLoc[2](loc0: S128)
B3:
MoveLoc[2](loc0: S128)
Ret
}
public(friend) value(Arg0: S128): u128 {
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
Ret
}
public(friend) sign(Arg0: S128): bool {
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Ret
}
public(friend) positive_value(Arg0: S128): u128 {
L1:	loc0: u128
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
BrFalse(8)
B1:
LdU128(0)
StLoc[1](loc0: u128)
Branch(12)
B2:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
StLoc[1](loc0: u128)
B3:
MoveLoc[1](loc0: u128)
Ret
}
public(friend) positive_number(Arg0: S128): S128 {
L1:	loc0: S128
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
BrFalse(10)
B1:
LdU128(0)
LdTrue
Pack[0](S128)
StLoc[1](loc0: S128)
Branch(12)
B2:
MoveLoc[0](Arg0: S128)
StLoc[1](loc0: S128)
B3:
MoveLoc[1](loc0: S128)
Ret
}
public(friend) negative_number(Arg0: S128): S128 {
L1:	loc0: S128
B0:
ImmBorrowLoc[0](Arg0: S128)
ImmBorrowField[1](S128.sign: bool)
ReadRef
Not
BrFalse(8)
B1:
MoveLoc[0](Arg0: S128)
StLoc[1](loc0: S128)
Branch(12)
B2:
LdU128(0)
LdTrue
Pack[0](S128)
StLoc[1](loc0: S128)
B3:
MoveLoc[1](loc0: S128)
Ret
}
normalize_zero(Arg0: &mut S128) {
B0:
CopyLoc[0](Arg0: &mut S128)
ImmBorrowField[0](S128.value: u128)
ReadRef
LdU128(0)
Eq
BrFalse(11)
B1:
LdTrue
MoveLoc[0](Arg0: &mut S128)
MutBorrowField[1](S128.sign: bool)
WriteRef
Branch(13)
B2:
MoveLoc[0](Arg0: &mut S128)
Pop
B3:
Ret
}
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/settlement.mvb280 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.settlement {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::bank;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::position;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::s128;
public(friend) trade_margin_settlement<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address, Arg2: address, Arg3: address, Arg4: S128, Arg5: S128, Arg6: u128) {
B0:
CopyLoc[0](Arg0: &mut Bank<Ty0>)
FreezeRef
CopyLoc[2](Arg2: address)
Call bank::exists_account<Ty0>(&Bank<Ty0>, address): bool
BrFalse(6)
B1:
Branch(10)
B2:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
LdU64(605)
Abort
B3:
CopyLoc[0](Arg0: &mut Bank<Ty0>)
FreezeRef
CopyLoc[3](Arg3: address)
Call bank::exists_account<Ty0>(&Bank<Ty0>, address): bool
BrFalse(16)
B4:
Branch(20)
B5:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
LdU64(605)
Abort
B6:
CopyLoc[4](Arg4: S128)
LdU128(0)
Call s128::gte_u128(S128, u128): bool
BrFalse(39)
B7:
CopyLoc[0](Arg0: &mut Bank<Ty0>)
CopyLoc[1](Arg1: address)
MoveLoc[2](Arg2: address)
MoveLoc[4](Arg4: S128)
LdU64(0)
CopyLoc[6](Arg6: u128)
Call transfer_based_on_fundsflow<Ty0>(&mut Bank<Ty0>, address, address, S128, u64, u128)
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MoveLoc[1](Arg1: address)
MoveLoc[3](Arg3: address)
MoveLoc[5](Arg5: S128)
LdU64(1)
MoveLoc[6](Arg6: u128)
Call transfer_based_on_fundsflow<Ty0>(&mut Bank<Ty0>, address, address, S128, u64, u128)
Branch(53)
B8:
CopyLoc[0](Arg0: &mut Bank<Ty0>)
CopyLoc[1](Arg1: address)
MoveLoc[3](Arg3: address)
MoveLoc[5](Arg5: S128)
LdU64(1)
CopyLoc[6](Arg6: u128)
Call transfer_based_on_fundsflow<Ty0>(&mut Bank<Ty0>, address, address, S128, u64, u128)
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MoveLoc[1](Arg1: address)
MoveLoc[2](Arg2: address)
MoveLoc[4](Arg4: S128)
LdU64(0)
MoveLoc[6](Arg6: u128)
Call transfer_based_on_fundsflow<Ty0>(&mut Bank<Ty0>, address, address, S128, u64, u128)
B9:
Ret
}
public(friend) get_margin_left(Arg0: &Position, Arg1: u128, Arg2: u128): u128 {
L3:	loc0: u128
L4:	loc1: u128
L5:	loc2: u128
L6:	loc3: u128
B0:
CopyLoc[0](Arg0: &Position)
Call position::compute_average_entry_price(&Position): u128
StLoc[6](loc3: u128)
CopyLoc[0](Arg0: &Position)
Call position::margin(&Position): u128
StLoc[3](loc0: u128)
CopyLoc[0](Arg0: &Position)
Call position::oi_open(&Position): u128
StLoc[5](loc2: u128)
MoveLoc[0](Arg0: &Position)
Call position::is_long(&Position): bool
BrFalse(23)
B1:
MoveLoc[3](loc0: u128)
CopyLoc[5](loc2: u128)
MoveLoc[1](Arg1: u128)
Mul
MoveLoc[6](loc3: u128)
Div
Add
MoveLoc[5](loc2: u128)
Call library::sub(u128, u128): u128
StLoc[4](loc1: u128)
Branch(33)
B2:
MoveLoc[3](loc0: u128)
CopyLoc[5](loc2: u128)
Add
MoveLoc[5](loc2: u128)
MoveLoc[1](Arg1: u128)
Mul
MoveLoc[6](loc3: u128)
Div
Call library::sub(u128, u128): u128
StLoc[4](loc1: u128)
B3:
MoveLoc[4](loc1: u128)
MoveLoc[2](Arg2: u128)
Call library::min(u128, u128): u128
Ret
}
public(friend) get_target_margin(Arg0: &Position, Arg1: u128, Arg2: u128): u128 {
L3:	loc0: u128
L4:	loc1: u128
L5:	loc2: u128
L6:	loc3: u128
B0:
CopyLoc[0](Arg0: &Position)
Call position::oi_open(&Position): u128
StLoc[4](loc1: u128)
CopyLoc[0](Arg0: &Position)
Call position::size(&Position): u128
MoveLoc[2](Arg2: u128)
Call library::base_mul(u128, u128): u128
StLoc[3](loc0: u128)
CopyLoc[3](loc0: u128)
MoveLoc[1](Arg1: u128)
Call library::base_div(u128, u128): u128
StLoc[6](loc3: u128)
MoveLoc[0](Arg0: &Position)
Call position::is_long(&Position): bool
BrFalse(22)
B1:
MoveLoc[6](loc3: u128)
MoveLoc[4](loc1: u128)
Add
MoveLoc[3](loc0: u128)
Call library::sub(u128, u128): u128
StLoc[5](loc2: u128)
Branch(28)
B2:
MoveLoc[6](loc3: u128)
MoveLoc[3](loc0: u128)
Add
MoveLoc[4](loc1: u128)
Call library::sub(u128, u128): u128
StLoc[5](loc2: u128)
B3:
MoveLoc[5](loc2: u128)
Ret
}
public(friend) get_max_removeable_margin(Arg0: Position, Arg1: u128): u128 {
L2:	loc0: u128
L3:	loc1: u128
L4:	loc2: u128
L5:	loc3: u128
L6:	loc4: u128
L7:	loc5: u128
L8:	loc6: u128
L9:	loc7: u128
L10:	loc8: u128
B0:
ImmBorrowLoc[0](Arg0: Position)
Call position::mro(&Position): u128
StLoc[6](loc4: u128)
ImmBorrowLoc[0](Arg0: Position)
Call position::margin(&Position): u128
StLoc[2](loc0: u128)
ImmBorrowLoc[0](Arg0: Position)
Call position::oi_open(&Position): u128
StLoc[8](loc6: u128)
ImmBorrowLoc[0](Arg0: Position)
Call position::size(&Position): u128
MoveLoc[1](Arg1: u128)
Call library::base_mul(u128, u128): u128
StLoc[7](loc5: u128)
ImmBorrowLoc[0](Arg0: Position)
Call position::is_long(&Position): bool
BrFalse(35)
B1:
Call library::base_uint(): u128
MoveLoc[6](loc4: u128)
Sub
StLoc[4](loc2: u128)
MoveLoc[7](loc5: u128)
MoveLoc[4](loc2: u128)
Call library::base_mul(u128, u128): u128
StLoc[9](loc7: u128)
CopyLoc[2](loc0: u128)
MoveLoc[2](loc0: u128)
MoveLoc[8](loc6: u128)
Call s128::from_subtraction(u128, u128): S128
MoveLoc[9](loc7: u128)
Call s128::add_u128(S128, u128): S128
Call s128::positive_value(S128): u128
Call library::min(u128, u128): u128
StLoc[3](loc1: u128)
Branch(51)
B2:
Call library::base_uint(): u128
MoveLoc[6](loc4: u128)
Add
StLoc[5](loc3: u128)
MoveLoc[7](loc5: u128)
MoveLoc[5](loc3: u128)
Call library::base_mul(u128, u128): u128
StLoc[10](loc8: u128)
CopyLoc[2](loc0: u128)
MoveLoc[2](loc0: u128)
MoveLoc[8](loc6: u128)
Add
MoveLoc[10](loc8: u128)
Call library::sub(u128, u128): u128
Call library::min(u128, u128): u128
StLoc[3](loc1: u128)
B3:
MoveLoc[3](loc1: u128)
Ret
}
transfer_based_on_fundsflow<Ty0>(Arg0: &mut Bank<Ty0>, Arg1: address, Arg2: address, Arg3: S128, Arg4: u64, Arg5: u128) {
L6:	loc0: address
L7:	loc1: u64
L8:	loc2: address
B0:
CopyLoc[3](Arg3: S128)
Call s128::value(S128): u128
LdU128(0)
Eq
BrFalse(8)
B1:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
Pop
Ret
B2:
CopyLoc[3](Arg3: S128)
LdU128(0)
Call s128::gt_u128(S128, u128): bool
BrFalse(19)
B3:
MoveLoc[2](Arg2: address)
StLoc[8](loc2: address)
MoveLoc[1](Arg1: address)
StLoc[6](loc0: address)
MoveLoc[4](Arg4: u64)
StLoc[7](loc1: u64)
Branch(25)
B4:
MoveLoc[1](Arg1: address)
StLoc[8](loc2: address)
MoveLoc[2](Arg2: address)
StLoc[6](loc0: address)
LdU64(2)
StLoc[7](loc1: u64)
B5:
MoveLoc[0](Arg0: &mut Bank<Ty0>)
MoveLoc[8](loc2: address)
MoveLoc[6](loc0: address)
MoveLoc[3](Arg3: S128)
Call s128::value(S128): u128
MoveLoc[7](loc1: u64)
MoveLoc[5](Arg5: u128)
Call bank::transfer<Ty0>(&mut Bank<Ty0>, address, address, u128, u64, u128)
Ret
}
}

0xa5b1b7a4cc8a765b422f41b8cfbc43553574f5731abdfa038df8d3cce09efec9/bytecode/sub_accounts.mvb401 lines

// Move bytecode v7
module 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001.sub_accounts {
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::library;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::protocol;
use 978fed071cca22dd26bec3cf4a5d5a00ab10f39cb8c659bbfdfbec4397241001::roles;
use 9041eddbe15edba576c8c0bd4237e07b19e2c17fb59b240658f96522261f10c4::payload;
use 9041eddbe15edba576c8c0bd4237e07b19e2c17fb59b240658f96522261f10c4::signature;
use 9041eddbe15edba576c8c0bd4237e07b19e2c17fb59b240658f96522261f10c4::unified_address;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct SubAccountUpdateEvent has copy, drop {
	account: address,
	sub_account: address,
	status: bool
}
struct TxIndexerCreationEvent has copy, drop {
	id: ID
}
struct SubAccounts has key {
	id: UID,
	map: Table<address, VecSet<address>>
}
struct TxIndexer has key {
	id: UID,
	counter: u128,
	map: Table<vector<u8>, bool>
}
entry create_tx_indexer(Arg0: &ProtocolConfig, Arg1: &ExchangeManagerCap, Arg2: &mut TxContext) {
L3:	loc0: TxIndexer
B0:
CopyLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[0](Arg0: &ProtocolConfig)
MoveLoc[1](Arg1: &ExchangeManagerCap)
Call roles::check_manager_validity(&ProtocolConfig, &ExchangeManagerCap)
CopyLoc[2](Arg2: &mut TxContext)
Call object::new(&mut TxContext): UID
LdU128(0)
MoveLoc[2](Arg2: &mut TxContext)
Call table::new<vector<u8>, bool>(&mut TxContext): Table<vector<u8>, bool>
Pack[3](TxIndexer)
StLoc[3](loc0: TxIndexer)
ImmBorrowLoc[3](loc0: TxIndexer)
ImmBorrowField[0](TxIndexer.id: UID)
Call object::uid_to_inner(&UID): ID
Pack[1](TxIndexerCreationEvent)
Call event::emit<TxIndexerCreationEvent>(TxIndexerCreationEvent)
MoveLoc[3](loc0: TxIndexer)
Call transfer::share_object<TxIndexer>(TxIndexer)
Ret
}
entry set_sub_account(Arg0: &ProtocolConfig, Arg1: &mut SubAccounts, Arg2: address, Arg3: bool, Arg4: &TxContext) {
L5:	loc0: address
B0:
MoveLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[4](Arg4: &TxContext)
Call tx_context::sender(&TxContext): address
StLoc[5](loc0: address)
MoveLoc[1](Arg1: &mut SubAccounts)
MoveLoc[5](loc0: address)
MoveLoc[2](Arg2: address)
MoveLoc[3](Arg3: bool)
Call set_sub_account_internal(&mut SubAccounts, address, address, bool)
Ret
}
entry set_sub_account_v2(Arg0: &ProtocolConfig, Arg1: &mut SubAccounts, Arg2: &mut TxIndexer, Arg3: &Clock, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: bool, Arg7: u128, Arg8: u64, Arg9: vector<u8>, Arg10: vector<u8>) {
L11:	loc0: u64
L12:	loc1: &Clock
L13:	loc2: vector<u8>
L14:	loc3: vector<u8>
L15:	loc4: vector<u8>
L16:	loc5: vector<address>
L17:	loc6: &UnifiedAddress
L18:	loc7: vector<u8>
L19:	loc8: UnifiedAddress
L20:	loc9: UnifiedAddress
B0:
MoveLoc[0](Arg0: &ProtocolConfig)
Call protocol::check_basic(&ProtocolConfig)
MoveLoc[4](Arg4: vector<u8>)
Call unified_address::from_tagged_bytes(vector<u8>): UnifiedAddress
StLoc[20](loc9: UnifiedAddress)
MoveLoc[5](Arg5: vector<u8>)
Call unified_address::from_tagged_bytes(vector<u8>): UnifiedAddress
StLoc[19](loc8: UnifiedAddress)
MoveLoc[3](Arg3: &Clock)
StLoc[12](loc1: &Clock)
CopyLoc[8](Arg8: u64)
StLoc[11](loc0: u64)
MoveLoc[12](loc1: &Clock)
MoveLoc[11](loc0: u64)
LdU64(34)
Call signature::assert_signed_payload_fresh(&Clock, u64, u64)
CopyLoc[20](loc9: UnifiedAddress)
CopyLoc[19](loc8: UnifiedAddress)
CopyLoc[6](Arg6: bool)
MoveLoc[7](Arg7: u128)
MoveLoc[8](Arg8: u64)
Call payload::set_sub_account(UnifiedAddress, UnifiedAddress, bool, u128, u64): vector<u8>
StLoc[18](loc7: vector<u8>)
ImmBorrowLoc[20](loc9: UnifiedAddress)
StLoc[17](loc6: &UnifiedAddress)
VecPack(24, 0)
StLoc[16](loc5: vector<address>)
CopyLoc[18](loc7: vector<u8>)
StLoc[15](loc4: vector<u8>)
MoveLoc[9](Arg9: vector<u8>)
StLoc[14](loc3: vector<u8>)
MoveLoc[10](Arg10: vector<u8>)
StLoc[13](loc2: vector<u8>)
MoveLoc[17](loc6: &UnifiedAddress)
MoveLoc[16](loc5: vector<address>)
MoveLoc[15](loc4: vector<u8>)
MoveLoc[14](loc3: vector<u8>)
MoveLoc[13](loc2: vector<u8>)
LdU64(52)
Call signature::verify_user_signature(&UnifiedAddress, vector<address>, vector<u8>, vector<u8>, vector<u8>, u64): UnifiedAddress
Pop
MoveLoc[2](Arg2: &mut TxIndexer)
MoveLoc[18](loc7: vector<u8>)
Call library::get_hash(vector<u8>): vector<u8>
Call validate_unique_tx(&mut TxIndexer, vector<u8>): u128
Pop
MoveLoc[1](Arg1: &mut SubAccounts)
ImmBorrowLoc[20](loc9: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
ImmBorrowLoc[19](loc8: UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
MoveLoc[6](Arg6: bool)
Call set_sub_account_internal(&mut SubAccounts, address, address, bool)
Ret
}
public(friend) assert_signed_action_sender_authorized(Arg0: &ProtocolConfig, Arg1: &SubAccounts, Arg2: &UnifiedAddress, Arg3: &TxContext) {
L4:	loc0: bool
L5:	loc1: address
L6:	loc2: address
B0:
MoveLoc[3](Arg3: &TxContext)
Call tx_context::sender(&TxContext): address
StLoc[5](loc1: address)
MoveLoc[2](Arg2: &UnifiedAddress)
Call unified_address::identifier(&UnifiedAddress): address
StLoc[6](loc2: address)
CopyLoc[5](loc1: address)
MoveLoc[0](Arg0: &ProtocolConfig)
Call protocol::gas_relayer(&ProtocolConfig): address
Eq
BrFalse(16)
B1:
MoveLoc[1](Arg1: &SubAccounts)
Pop
LdTrue
StLoc[4](loc0: bool)
Branch(30)
B2:
CopyLoc[5](loc1: address)
CopyLoc[6](loc2: address)
Eq
BrFalse(25)
B3:
MoveLoc[1](Arg1: &SubAccounts)
Pop
LdTrue
StLoc[4](loc0: bool)
Branch(30)
B4:
MoveLoc[1](Arg1: &SubAccounts)
MoveLoc[6](loc2: address)
MoveLoc[5](loc1: address)
Call is_sub_account(&SubAccounts, address, address): bool
StLoc[4](loc0: bool)
B5:
MoveLoc[4](loc0: bool)
BrFalse(33)
B6:
Branch(35)
B7:
LdU64(920)
Abort
B8:
Ret
}
public(friend) set_sub_account_internal(Arg0: &mut SubAccounts, Arg1: address, Arg2: address, Arg3: bool) {
L4:	loc0: &mut Table<address, VecSet<address>>
L5:	loc1: &mut VecSet<address>
B0:
CopyLoc[2](Arg2: address)
LdConst[0](address: 0x00..)
Neq
BrFalse(5)
B1:
Branch(9)
B2:
MoveLoc[0](Arg0: &mut SubAccounts)
Pop
LdU64(105)
Abort
B3:
MoveLoc[0](Arg0: &mut SubAccounts)
MutBorrowField[1](SubAccounts.map: Table<address, VecSet<address>>)
StLoc[4](loc0: &mut Table<address, VecSet<address>>)
CopyLoc[4](loc0: &mut Table<address, VecSet<address>>)
FreezeRef
CopyLoc[1](Arg1: address)
Call table::contains<address, VecSet<address>>(&Table<address, VecSet<address>>, address): bool
Not
BrFalse(22)
B4:
CopyLoc[4](loc0: &mut Table<address, VecSet<address>>)
CopyLoc[1](Arg1: address)
Call vec_set::empty<address>(): VecSet<address>
Call table::add<address, VecSet<address>>(&mut Table<address, VecSet<address>>, address, VecSet<address>)
B5:
MoveLoc[4](loc0: &mut Table<address, VecSet<address>>)
CopyLoc[1](Arg1: address)
Call table::borrow_mut<address, VecSet<address>>(&mut Table<address, VecSet<address>>, address): &mut VecSet<address>
StLoc[5](loc1: &mut VecSet<address>)
CopyLoc[3](Arg3: bool)
BrFalse(41)
B6:
CopyLoc[5](loc1: &mut VecSet<address>)
FreezeRef
ImmBorrowLoc[2](Arg2: address)
Call vec_set::contains<address>(&VecSet<address>, &address): bool
Not
BrFalse(38)
B7:
MoveLoc[5](loc1: &mut VecSet<address>)
CopyLoc[2](Arg2: address)
Call vec_set::insert<address>(&mut VecSet<address>, address)
Branch(52)
B8:
MoveLoc[5](loc1: &mut VecSet<address>)
Pop
Branch(52)
B9:
CopyLoc[5](loc1: &mut VecSet<address>)
FreezeRef
ImmBorrowLoc[2](Arg2: address)
Call vec_set::contains<address>(&VecSet<address>, &address): bool
BrFalse(50)
B10:
MoveLoc[5](loc1: &mut VecSet<address>)
ImmBorrowLoc[2](Arg2: address)
Call vec_set::remove<address>(&mut VecSet<address>, &address)
Branch(52)
B11:
MoveLoc[5](loc1: &mut VecSet<address>)
Pop
B12:
MoveLoc[1](Arg1: address)
MoveLoc[2](Arg2: address)
MoveLoc[3](Arg3: bool)
Pack[0](SubAccountUpdateEvent)
Call event::emit<SubAccountUpdateEvent>(SubAccountUpdateEvent)
Ret
}
public(friend) initialize(Arg0: &mut TxContext) {
B0:
CopyLoc[0](Arg0: &mut TxContext)
Call object::new(&mut TxContext): UID
CopyLoc[0](Arg0: &mut TxContext)
Call table::new<address, VecSet<address>>(&mut TxContext): Table<address, VecSet<address>>
Pack[2](SubAccounts)
Call transfer::share_object<SubAccounts>(SubAccounts)
CopyLoc[0](Arg0: &mut TxContext)
Call object::new(&mut TxContext): UID
LdU128(0)
MoveLoc[0](Arg0: &mut TxContext)
Call table::new<vector<u8>, bool>(&mut TxContext): Table<vector<u8>, bool>
Pack[3](TxIndexer)
Call transfer::share_object<TxIndexer>(TxIndexer)
Ret
}
public(friend) validate_unique_tx(Arg0: &mut TxIndexer, Arg1: vector<u8>): u128 {
B0:
CopyLoc[0](Arg0: &mut TxIndexer)
ImmBorrowField[2](TxIndexer.map: Table<vector<u8>, bool>)
CopyLoc[1](Arg1: vector<u8>)
Call table::contains<vector<u8>, bool>(&Table<vector<u8>, bool>, vector<u8>): bool
Not
BrFalse(7)
B1:
Branch(11)
B2:
MoveLoc[0](Arg0: &mut TxIndexer)
Pop
LdU64(906)
Abort
B3:
CopyLoc[0](Arg0: &mut TxIndexer)
MutBorrowField[2](TxIndexer.map: Table<vector<u8>, bool>)
MoveLoc[1](Arg1: vector<u8>)
LdTrue
Call table::add<vector<u8>, bool>(&mut Table<vector<u8>, bool>, vector<u8>, bool)
CopyLoc[0](Arg0: &mut TxIndexer)
ImmBorrowField[3](TxIndexer.counter: u128)
ReadRef
LdU128(1)
Add
CopyLoc[0](Arg0: &mut TxIndexer)
MutBorrowField[3](TxIndexer.counter: u128)
WriteRef
MoveLoc[0](Arg0: &mut TxIndexer)
ImmBorrowField[3](TxIndexer.counter: u128)
ReadRef
Ret
}
public(friend) increment_tx_index(Arg0: &mut TxIndexer): u128 {
B0:
CopyLoc[0](Arg0: &mut TxIndexer)
ImmBorrowField[3](TxIndexer.counter: u128)
ReadRef
LdU128(1)
Add
CopyLoc[0](Arg0: &mut TxIndexer)
MutBorrowField[3](TxIndexer.counter: u128)
WriteRef
MoveLoc[0](Arg0: &mut TxIndexer)
ImmBorrowField[3](TxIndexer.counter: u128)
ReadRef
Ret
}
public(friend) is_sub_account(Arg0: &SubAccounts, Arg1: address, Arg2: address): bool {
L3:	loc0: &Table<address, VecSet<address>>
B0:
MoveLoc[0](Arg0: &SubAccounts)
ImmBorrowField[1](SubAccounts.map: Table<address, VecSet<address>>)
StLoc[3](loc0: &Table<address, VecSet<address>>)
CopyLoc[3](loc0: &Table<address, VecSet<address>>)
CopyLoc[1](Arg1: address)
Call table::contains<address, VecSet<address>>(&Table<address, VecSet<address>>, address): bool
Not
BrFalse(12)
B1:
MoveLoc[3](loc0: &Table<address, VecSet<address>>)
Pop
LdFalse
Ret
B2:
MoveLoc[3](loc0: &Table<address, VecSet<address>>)
MoveLoc[1](Arg1: address)
Call table::borrow<address, VecSet<address>>(&Table<address, VecSet<address>>, address): &VecSet<address>
ImmBorrowLoc[2](Arg2: address)
Call vec_set::contains<address>(&VecSet<address>, &address): bool
Ret
}
public(friend) get_all_sub_accounts(Arg0: &SubAccounts, Arg1: address): vector<address> {
L2:	loc0: vector<address>
L3:	loc1: &Table<address, VecSet<address>>
B0:
MoveLoc[0](Arg0: &SubAccounts)
ImmBorrowField[1](SubAccounts.map: Table<address, VecSet<address>>)
StLoc[3](loc1: &Table<address, VecSet<address>>)
CopyLoc[3](loc1: &Table<address, VecSet<address>>)
CopyLoc[1](Arg1: address)
Call table::contains<address, VecSet<address>>(&Table<address, VecSet<address>>, address): bool
BrFalse(14)
B1:
MoveLoc[3](loc1: &Table<address, VecSet<address>>)
MoveLoc[1](Arg1: address)
Call table::borrow<address, VecSet<address>>(&Table<address, VecSet<address>>, address): &VecSet<address>
Call vec_set::keys<address>(&VecSet<address>): &vector<address>
ReadRef
StLoc[2](loc0: vector<address>)
Branch(18)
B2:
MoveLoc[3](loc1: &Table<address, VecSet<address>>)
Pop
VecPack(24, 0)
StLoc[2](loc0: vector<address>)
B3:
MoveLoc[2](loc0: vector<address>)
Ret
}
Constants [
=> address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

This is a circuit, not a contract. It declares no ABI and no storage layout, so there is no interface list and no slot mapping to show. The source above is the whole of what it publishes.

Deployments

This code is deployed at one address. Any other address running the same bytecode would appear here too, already verified.