1233 lines
36 KiB
Rust
1233 lines
36 KiB
Rust
use super::*;
|
|
|
|
#[tokio::test]
|
|
async fn test_perp_settle_pnl_basic() -> Result<(), TransportError> {
|
|
let mut test_builder = TestContextBuilder::new();
|
|
test_builder.test().set_compute_max_units(90_000); // the divisions in perp_max_settle are costly!
|
|
let context = test_builder.start_default().await;
|
|
let solana = &context.solana.clone();
|
|
|
|
let admin = TestKeypair::new();
|
|
let owner = context.users[0].key;
|
|
let payer = context.users[1].key;
|
|
let mints = &context.mints[0..=3];
|
|
|
|
let initial_token_deposit = 10_000;
|
|
|
|
//
|
|
// SETUP: Create a group and an account
|
|
//
|
|
|
|
let GroupWithTokens { group, tokens, .. } = GroupWithTokensConfig {
|
|
admin,
|
|
payer,
|
|
mints: mints.to_vec(),
|
|
..GroupWithTokensConfig::default()
|
|
}
|
|
.create(solana)
|
|
.await;
|
|
|
|
let settler =
|
|
create_funded_account(&solana, group, owner, 251, &context.users[1], &[], 0, 0).await;
|
|
let settler_owner = owner.clone();
|
|
|
|
let account_0 = create_funded_account(
|
|
&solana,
|
|
group,
|
|
owner,
|
|
0,
|
|
&context.users[1],
|
|
&mints[0..1],
|
|
initial_token_deposit,
|
|
0,
|
|
)
|
|
.await;
|
|
let account_1 = create_funded_account(
|
|
&solana,
|
|
group,
|
|
owner,
|
|
1,
|
|
&context.users[1],
|
|
&mints[0..1],
|
|
initial_token_deposit,
|
|
0,
|
|
)
|
|
.await;
|
|
|
|
//
|
|
// TEST: Create a perp market
|
|
//
|
|
let mango_v4::accounts::PerpCreateMarket { perp_market, .. } = send_tx(
|
|
solana,
|
|
PerpCreateMarketInstruction {
|
|
group,
|
|
admin,
|
|
payer,
|
|
perp_market_index: 0,
|
|
quote_lot_size: 10,
|
|
base_lot_size: 100,
|
|
maint_base_asset_weight: 0.975,
|
|
init_base_asset_weight: 0.95,
|
|
maint_base_liab_weight: 1.025,
|
|
init_base_liab_weight: 1.05,
|
|
base_liquidation_fee: 0.012,
|
|
maker_fee: 0.0002,
|
|
taker_fee: 0.000,
|
|
settle_pnl_limit_factor: 0.2,
|
|
settle_pnl_limit_window_size_ts: 24 * 60 * 60,
|
|
..PerpCreateMarketInstruction::with_new_book_and_queue(&solana, &tokens[1]).await
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
//
|
|
// TEST: Create another perp market
|
|
//
|
|
let mango_v4::accounts::PerpCreateMarket {
|
|
perp_market: perp_market_2,
|
|
..
|
|
} = send_tx(
|
|
solana,
|
|
PerpCreateMarketInstruction {
|
|
group,
|
|
admin,
|
|
payer,
|
|
perp_market_index: 1,
|
|
quote_lot_size: 10,
|
|
base_lot_size: 100,
|
|
maint_base_asset_weight: 0.975,
|
|
init_base_asset_weight: 0.95,
|
|
maint_base_liab_weight: 1.025,
|
|
init_base_liab_weight: 1.05,
|
|
base_liquidation_fee: 0.012,
|
|
maker_fee: 0.0002,
|
|
taker_fee: 0.000,
|
|
settle_pnl_limit_factor: 0.2,
|
|
settle_pnl_limit_window_size_ts: 24 * 60 * 60,
|
|
..PerpCreateMarketInstruction::with_new_book_and_queue(&solana, &tokens[2]).await
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
let price_lots = {
|
|
let perp_market = solana.get_account::<PerpMarket>(perp_market).await;
|
|
perp_market.native_price_to_lot(I80F48::from(1000))
|
|
};
|
|
|
|
// Set the initial oracle price
|
|
set_perp_stub_oracle_price(solana, group, perp_market, &tokens[1], admin, 1000.0).await;
|
|
|
|
//
|
|
// Place orders and create a position
|
|
//
|
|
send_tx(
|
|
solana,
|
|
PerpPlaceOrderInstruction {
|
|
account: account_0,
|
|
perp_market,
|
|
owner,
|
|
side: Side::Bid,
|
|
price_lots,
|
|
max_base_lots: 1,
|
|
..PerpPlaceOrderInstruction::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpPlaceOrderInstruction {
|
|
account: account_1,
|
|
perp_market,
|
|
owner,
|
|
side: Side::Ask,
|
|
price_lots,
|
|
max_base_lots: 1,
|
|
..PerpPlaceOrderInstruction::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpConsumeEventsInstruction {
|
|
perp_market,
|
|
mango_accounts: vec![account_0, account_1],
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
{
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
|
|
assert_eq!(mango_account_0.perps[0].base_position_lots(), 1);
|
|
assert_eq!(mango_account_1.perps[0].base_position_lots(), -1);
|
|
assert_eq!(
|
|
mango_account_0.perps[0].quote_position_native().round(),
|
|
-100_020
|
|
);
|
|
assert_eq!(mango_account_1.perps[0].quote_position_native(), 100_000);
|
|
}
|
|
|
|
// Cannot settle with yourself
|
|
send_tx_expect_error!(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_0,
|
|
perp_market,
|
|
},
|
|
MangoError::CannotSettleWithSelf
|
|
);
|
|
|
|
// Cannot settle position that does not exist
|
|
send_tx_expect_error!(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_1,
|
|
perp_market: perp_market_2,
|
|
},
|
|
MangoError::PerpPositionDoesNotExist
|
|
);
|
|
|
|
// TODO: Test funding settlement
|
|
|
|
{
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
let bank = solana.get_account::<Bank>(tokens[0].bank).await;
|
|
assert_eq!(
|
|
mango_account_0.tokens[0].native(&bank).round(),
|
|
initial_token_deposit,
|
|
"account 0 has expected amount of tokens"
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.tokens[0].native(&bank).round(),
|
|
initial_token_deposit,
|
|
"account 1 has expected amount of tokens"
|
|
);
|
|
}
|
|
|
|
// Try and settle with high price
|
|
set_perp_stub_oracle_price(solana, group, perp_market, &tokens[1], admin, 1200.0).await;
|
|
|
|
// Account a must be the profitable one
|
|
send_tx_expect_error!(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_1,
|
|
account_b: account_0,
|
|
perp_market,
|
|
},
|
|
MangoError::ProfitabilityMismatch
|
|
);
|
|
|
|
// Change the oracle to a more reasonable price
|
|
set_perp_stub_oracle_price(solana, group, perp_market, &tokens[1], admin, 1005.0).await;
|
|
|
|
let expected_pnl_0 = I80F48::from(480); // Less due to fees
|
|
let expected_pnl_1 = I80F48::from(-500);
|
|
|
|
{
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
let perp_market = solana.get_account::<PerpMarket>(perp_market).await;
|
|
assert_eq!(
|
|
mango_account_0.perps[0]
|
|
.unsettled_pnl(&perp_market, I80F48::from(1005))
|
|
.unwrap()
|
|
.round(),
|
|
expected_pnl_0
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0]
|
|
.unsettled_pnl(&perp_market, I80F48::from(1005))
|
|
.unwrap(),
|
|
expected_pnl_1
|
|
);
|
|
}
|
|
|
|
// Change the oracle to a very high price, such that the pnl exceeds the account funding
|
|
set_perp_stub_oracle_price(solana, group, perp_market, &tokens[1], admin, 1500.0).await;
|
|
|
|
let expected_pnl_0 = I80F48::from(50000 - 20);
|
|
let expected_pnl_1 = I80F48::from(-50000);
|
|
|
|
{
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
let perp_market = solana.get_account::<PerpMarket>(perp_market).await;
|
|
assert_eq!(
|
|
mango_account_0.perps[0]
|
|
.unsettled_pnl(&perp_market, I80F48::from(1500))
|
|
.unwrap()
|
|
.round(),
|
|
expected_pnl_0
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0]
|
|
.unsettled_pnl(&perp_market, I80F48::from(1500))
|
|
.unwrap(),
|
|
expected_pnl_1
|
|
);
|
|
}
|
|
|
|
//
|
|
// SETUP: Add some non-settle token, so the account's health has more contributions
|
|
//
|
|
send_tx(
|
|
solana,
|
|
TokenDepositInstruction {
|
|
amount: 1001,
|
|
reduce_only: false,
|
|
account: account_1,
|
|
owner,
|
|
token_account: context.users[1].token_accounts[2],
|
|
token_authority: payer.clone(),
|
|
bank_index: 0,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Settle as much PNL as account_1's health allows:
|
|
// The account perp_settle_health is 0.8 * 10000.0 + 0.8 * 1001.0,
|
|
// meaning we can bring it to zero by settling 10000 * 0.8 / 0.8 + 1001 * 0.8 / 1.2 = 10667.333
|
|
// because then we'd be left with -667.333 * 1.2 + 0.8 * 1000 = 0
|
|
let expected_total_settle = I80F48::from(10667);
|
|
send_tx(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_1,
|
|
perp_market,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
{
|
|
let bank = solana.get_account::<Bank>(tokens[0].bank).await;
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
|
|
assert_eq!(
|
|
mango_account_0.perps[0].base_position_lots(),
|
|
1,
|
|
"base position unchanged for account 0"
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0].base_position_lots(),
|
|
-1,
|
|
"base position unchanged for account 1"
|
|
);
|
|
|
|
assert_eq!(
|
|
mango_account_0.perps[0].quote_position_native().round(),
|
|
I80F48::from(-100_020) - expected_total_settle,
|
|
"quote position reduced for profitable position"
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0].quote_position_native().round(),
|
|
I80F48::from(100_000) + expected_total_settle,
|
|
"quote position increased for losing position by opposite of first account"
|
|
);
|
|
|
|
assert_eq!(
|
|
mango_account_0.tokens[0].native(&bank).round(),
|
|
I80F48::from(initial_token_deposit) + expected_total_settle,
|
|
"account 0 token native position increased (profit)"
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.tokens[0].native(&bank).round(),
|
|
I80F48::from(initial_token_deposit) - expected_total_settle,
|
|
"account 1 token native position decreased (loss)"
|
|
);
|
|
|
|
assert_eq!(
|
|
mango_account_0.perp_spot_transfers, expected_total_settle,
|
|
"net_settled on account 0 updated with profit from settlement"
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perp_spot_transfers, -expected_total_settle,
|
|
"net_settled on account 1 updated with loss from settlement"
|
|
);
|
|
assert_eq!(
|
|
mango_account_0.perps[0].perp_spot_transfers, expected_total_settle,
|
|
"net_settled on account 0 updated with profit from settlement"
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0].perp_spot_transfers, -expected_total_settle,
|
|
"net_settled on account 1 updated with loss from settlement"
|
|
);
|
|
}
|
|
|
|
// Change the oracle to a reasonable price in other direction
|
|
set_perp_stub_oracle_price(solana, group, perp_market, &tokens[1], admin, 995.0).await;
|
|
|
|
let expected_pnl_0 = I80F48::from(1 * 100 * 995 - 1 * 100 * 1000 - 20) - expected_total_settle;
|
|
let expected_pnl_1 = I80F48::from(-1 * 100 * 995 + 1 * 100 * 1000) + expected_total_settle;
|
|
|
|
{
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
let perp_market = solana.get_account::<PerpMarket>(perp_market).await;
|
|
assert_eq!(
|
|
mango_account_0.perps[0]
|
|
.unsettled_pnl(&perp_market, I80F48::from(995))
|
|
.unwrap()
|
|
.round(),
|
|
expected_pnl_0
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0]
|
|
.unsettled_pnl(&perp_market, I80F48::from(995))
|
|
.unwrap()
|
|
.round(),
|
|
expected_pnl_1
|
|
);
|
|
}
|
|
|
|
// Fully execute the settle
|
|
let expected_total_settle = expected_total_settle - expected_pnl_1;
|
|
send_tx(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_1,
|
|
account_b: account_0,
|
|
perp_market,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
{
|
|
let bank = solana.get_account::<Bank>(tokens[0].bank).await;
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
|
|
assert_eq!(
|
|
mango_account_0.perps[0].base_position_lots(),
|
|
1,
|
|
"base position unchanged for account 0"
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0].base_position_lots(),
|
|
-1,
|
|
"base position unchanged for account 1"
|
|
);
|
|
|
|
assert_eq!(
|
|
mango_account_0.perps[0].quote_position_native().round(),
|
|
I80F48::from(-100_020) - expected_total_settle,
|
|
"quote position increased for losing position"
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0].quote_position_native().round(),
|
|
I80F48::from(100_000) + expected_total_settle,
|
|
"quote position reduced for losing position by opposite of first account"
|
|
);
|
|
|
|
// 480 was previous settlement
|
|
assert_eq!(
|
|
mango_account_0.tokens[0].native(&bank).round(),
|
|
I80F48::from(initial_token_deposit) + expected_total_settle,
|
|
"account 0 token native position decreased (loss)"
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.tokens[0].native(&bank).round(),
|
|
I80F48::from(initial_token_deposit) - expected_total_settle,
|
|
"account 1 token native position increased (profit)"
|
|
);
|
|
|
|
assert_eq!(
|
|
mango_account_0.perp_spot_transfers, expected_total_settle,
|
|
"net_settled on account 0 updated with loss from settlement"
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perp_spot_transfers, -expected_total_settle,
|
|
"net_settled on account 1 updated with profit from settlement"
|
|
);
|
|
}
|
|
|
|
// no more settleable pnl left
|
|
{
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
let perp_market = solana.get_account::<PerpMarket>(perp_market).await;
|
|
assert_eq!(
|
|
mango_account_0.perps[0]
|
|
.unsettled_pnl(&perp_market, I80F48::from(995))
|
|
.unwrap()
|
|
.round(),
|
|
-20 // fees
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0]
|
|
.unsettled_pnl(&perp_market, I80F48::from(995))
|
|
.unwrap()
|
|
.round(),
|
|
0
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_perp_settle_pnl_fees() -> Result<(), TransportError> {
|
|
let mut test_builder = TestContextBuilder::new();
|
|
test_builder.test().set_compute_max_units(90_000);
|
|
let context = test_builder.start_default().await;
|
|
let solana = &context.solana.clone();
|
|
|
|
let admin = TestKeypair::new();
|
|
let owner = context.users[0].key;
|
|
let payer = context.users[1].key;
|
|
let mints = &context.mints[0..=2];
|
|
|
|
let initial_token_deposit = 10_000;
|
|
|
|
//
|
|
// SETUP: Create a group and accounts
|
|
//
|
|
|
|
let GroupWithTokens { group, tokens, .. } = GroupWithTokensConfig {
|
|
admin,
|
|
payer,
|
|
mints: mints.to_vec(),
|
|
zero_token_is_quote: true,
|
|
..GroupWithTokensConfig::default()
|
|
}
|
|
.create(solana)
|
|
.await;
|
|
let settle_bank = tokens[0].bank;
|
|
|
|
// ensure vaults are not empty
|
|
create_funded_account(
|
|
&solana,
|
|
group,
|
|
owner,
|
|
250,
|
|
&context.users[1],
|
|
mints,
|
|
100_000,
|
|
0,
|
|
)
|
|
.await;
|
|
|
|
let settler =
|
|
create_funded_account(&solana, group, owner, 251, &context.users[1], &[], 0, 0).await;
|
|
let settler_owner = owner.clone();
|
|
|
|
let account_0 = create_funded_account(
|
|
&solana,
|
|
group,
|
|
owner,
|
|
0,
|
|
&context.users[1],
|
|
&mints[0..1],
|
|
initial_token_deposit,
|
|
0,
|
|
)
|
|
.await;
|
|
let account_1 = create_funded_account(
|
|
&solana,
|
|
group,
|
|
owner,
|
|
1,
|
|
&context.users[1],
|
|
&mints[0..1],
|
|
initial_token_deposit,
|
|
0,
|
|
)
|
|
.await;
|
|
|
|
//
|
|
// SETUP: Create a perp market
|
|
//
|
|
let flat_fee = 1000;
|
|
let fee_low_health = 0.10;
|
|
let mango_v4::accounts::PerpCreateMarket { perp_market, .. } = send_tx(
|
|
solana,
|
|
PerpCreateMarketInstruction {
|
|
group,
|
|
admin,
|
|
payer,
|
|
perp_market_index: 0,
|
|
quote_lot_size: 10,
|
|
base_lot_size: 100,
|
|
maint_base_asset_weight: 1.0,
|
|
init_base_asset_weight: 1.0,
|
|
maint_base_liab_weight: 1.0,
|
|
init_base_liab_weight: 1.0,
|
|
base_liquidation_fee: 0.0,
|
|
maker_fee: 0.0,
|
|
taker_fee: 0.0,
|
|
settle_fee_flat: flat_fee as f32,
|
|
settle_fee_amount_threshold: 4000.0,
|
|
settle_fee_fraction_low_health: fee_low_health,
|
|
settle_pnl_limit_factor: 0.2,
|
|
settle_pnl_limit_window_size_ts: 24 * 60 * 60,
|
|
..PerpCreateMarketInstruction::with_new_book_and_queue(&solana, &tokens[1]).await
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
let price_lots = {
|
|
let perp_market = solana.get_account::<PerpMarket>(perp_market).await;
|
|
perp_market.native_price_to_lot(I80F48::from(1000))
|
|
};
|
|
|
|
// Set the initial oracle price
|
|
set_perp_stub_oracle_price(solana, group, perp_market, &tokens[1], admin, 1000.0).await;
|
|
|
|
//
|
|
// SETUP: Create a perp base position
|
|
//
|
|
send_tx(
|
|
solana,
|
|
PerpPlaceOrderInstruction {
|
|
account: account_0,
|
|
perp_market,
|
|
owner,
|
|
side: Side::Bid,
|
|
price_lots,
|
|
max_base_lots: 1,
|
|
..PerpPlaceOrderInstruction::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpPlaceOrderInstruction {
|
|
account: account_1,
|
|
perp_market,
|
|
owner,
|
|
side: Side::Ask,
|
|
price_lots,
|
|
max_base_lots: 1,
|
|
..PerpPlaceOrderInstruction::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpConsumeEventsInstruction {
|
|
perp_market,
|
|
mango_accounts: vec![account_0, account_1],
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
{
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
|
|
assert_eq!(mango_account_0.perps[0].base_position_lots(), 1);
|
|
assert_eq!(mango_account_1.perps[0].base_position_lots(), -1);
|
|
assert_eq!(
|
|
mango_account_0.perps[0].quote_position_native().round(),
|
|
-100_000
|
|
);
|
|
assert_eq!(mango_account_1.perps[0].quote_position_native(), 100_000);
|
|
}
|
|
|
|
//
|
|
// TEST: Settle (health is high)
|
|
//
|
|
set_perp_stub_oracle_price(solana, group, perp_market, &tokens[1], admin, 1050.0).await;
|
|
|
|
let expected_pnl = 5000;
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_1,
|
|
perp_market,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
let mut total_settled_pnl = expected_pnl;
|
|
let mut total_fees_paid = flat_fee;
|
|
{
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
assert_eq!(
|
|
mango_account_0.perps[0].quote_position_native().round(),
|
|
I80F48::from(-100_000 - total_settled_pnl)
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0].quote_position_native().round(),
|
|
I80F48::from(100_000 + total_settled_pnl),
|
|
);
|
|
assert_eq!(
|
|
account_position(solana, account_0, settle_bank).await,
|
|
initial_token_deposit as i64 + total_settled_pnl - total_fees_paid
|
|
);
|
|
assert_eq!(
|
|
account_position(solana, account_1, settle_bank).await,
|
|
initial_token_deposit as i64 - total_settled_pnl
|
|
);
|
|
assert_eq!(
|
|
account_position(solana, settler, settle_bank).await,
|
|
total_fees_paid
|
|
);
|
|
}
|
|
|
|
//
|
|
// Bring account_0 health low, specifically to
|
|
// init_health = 14000 - 1.4 * 1 * 10700 = -980
|
|
// maint_health = 14000 - 1.2 * 1 * 10700 = 1160
|
|
//
|
|
send_tx(
|
|
solana,
|
|
TokenWithdrawInstruction {
|
|
account: account_0,
|
|
owner,
|
|
token_account: context.users[1].token_accounts[2],
|
|
amount: 1,
|
|
allow_borrow: true,
|
|
bank_index: 0,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
set_bank_stub_oracle_price(solana, group, &tokens[2], admin, 10700.0).await;
|
|
|
|
//
|
|
// TEST: Settle (health is low), percent fee
|
|
//
|
|
set_perp_stub_oracle_price(solana, group, perp_market, &tokens[1], admin, 1070.0).await;
|
|
|
|
let expected_pnl = 2000;
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_1,
|
|
perp_market,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
total_settled_pnl += expected_pnl;
|
|
total_fees_paid +=
|
|
(expected_pnl as f64 * fee_low_health as f64 * 980.0 / (1160.0 + 980.0)) as i64 + 1;
|
|
{
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
assert_eq!(
|
|
mango_account_0.perps[0].quote_position_native().round(),
|
|
I80F48::from(-100_000 - total_settled_pnl)
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0].quote_position_native().round(),
|
|
I80F48::from(100_000 + total_settled_pnl),
|
|
);
|
|
assert_eq!(
|
|
account_position(solana, account_0, settle_bank).await,
|
|
initial_token_deposit as i64 + total_settled_pnl - total_fees_paid
|
|
);
|
|
assert_eq!(
|
|
account_position(solana, account_1, settle_bank).await,
|
|
initial_token_deposit as i64 - total_settled_pnl
|
|
);
|
|
assert_eq!(
|
|
account_position(solana, settler, settle_bank).await,
|
|
total_fees_paid
|
|
);
|
|
}
|
|
|
|
//
|
|
// TEST: Settle (health is low), no fee because pnl too small
|
|
//
|
|
set_perp_stub_oracle_price(solana, group, perp_market, &tokens[1], admin, 1071.0).await;
|
|
|
|
let expected_pnl = 100;
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_1,
|
|
perp_market,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
total_settled_pnl += expected_pnl;
|
|
total_fees_paid += 0;
|
|
{
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
assert_eq!(
|
|
mango_account_0.perps[0].quote_position_native().round(),
|
|
I80F48::from(-100_000 - total_settled_pnl)
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0].quote_position_native().round(),
|
|
I80F48::from(100_000 + total_settled_pnl),
|
|
);
|
|
assert_eq!(
|
|
account_position(solana, account_0, settle_bank).await,
|
|
initial_token_deposit as i64 + total_settled_pnl - total_fees_paid
|
|
);
|
|
assert_eq!(
|
|
account_position(solana, account_1, settle_bank).await,
|
|
initial_token_deposit as i64 - total_settled_pnl
|
|
);
|
|
assert_eq!(
|
|
account_position(solana, settler, settle_bank).await,
|
|
total_fees_paid
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_perp_pnl_settle_limit() -> Result<(), TransportError> {
|
|
let context = TestContext::new().await;
|
|
let solana = &context.solana.clone();
|
|
|
|
let admin = TestKeypair::new();
|
|
let owner = context.users[0].key;
|
|
let payer = context.users[1].key;
|
|
let mints = &context.mints[0..=2];
|
|
|
|
let initial_token_deposit = 1000_000;
|
|
|
|
//
|
|
// SETUP: Create a group and an account
|
|
//
|
|
|
|
let GroupWithTokens { group, tokens, .. } = GroupWithTokensConfig {
|
|
admin,
|
|
payer,
|
|
mints: mints.to_vec(),
|
|
..GroupWithTokensConfig::default()
|
|
}
|
|
.create(solana)
|
|
.await;
|
|
|
|
let settler =
|
|
create_funded_account(&solana, group, owner, 251, &context.users[1], &[], 0, 0).await;
|
|
let settler_owner = owner.clone();
|
|
|
|
let account_0 = create_funded_account(
|
|
&solana,
|
|
group,
|
|
owner,
|
|
0,
|
|
&context.users[1],
|
|
&mints[0..1],
|
|
initial_token_deposit,
|
|
0,
|
|
)
|
|
.await;
|
|
let account_1 = create_funded_account(
|
|
&solana,
|
|
group,
|
|
owner,
|
|
1,
|
|
&context.users[1],
|
|
&mints[0..1],
|
|
initial_token_deposit * 100, // Fund 100x, so that this is not the bound for what account_0 can settle
|
|
0,
|
|
)
|
|
.await;
|
|
|
|
//
|
|
// TEST: Create a perp market
|
|
//
|
|
let settle_pnl_limit_factor = 0.8;
|
|
let mango_v4::accounts::PerpCreateMarket { perp_market, .. } = send_tx(
|
|
solana,
|
|
PerpCreateMarketInstruction {
|
|
group,
|
|
admin,
|
|
payer,
|
|
perp_market_index: 0,
|
|
quote_lot_size: 10,
|
|
base_lot_size: 100,
|
|
maint_base_asset_weight: 0.975,
|
|
init_base_asset_weight: 0.95,
|
|
maint_base_liab_weight: 1.025,
|
|
init_base_liab_weight: 1.05,
|
|
base_liquidation_fee: 0.012,
|
|
maker_fee: 0.0,
|
|
taker_fee: 0.0,
|
|
settle_pnl_limit_factor,
|
|
settle_pnl_limit_window_size_ts: 24 * 60 * 60,
|
|
..PerpCreateMarketInstruction::with_new_book_and_queue(&solana, &tokens[1]).await
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
let price_lots = {
|
|
let perp_market = solana.get_account::<PerpMarket>(perp_market).await;
|
|
perp_market.native_price_to_lot(I80F48::from(1000))
|
|
};
|
|
|
|
// Set the initial oracle price
|
|
set_perp_stub_oracle_price(&solana, group, perp_market, &tokens[1], admin, 1000.0).await;
|
|
|
|
//
|
|
// Place orders and create a position
|
|
//
|
|
send_tx(
|
|
solana,
|
|
PerpPlaceOrderInstruction {
|
|
account: account_0,
|
|
perp_market,
|
|
owner,
|
|
side: Side::Bid,
|
|
price_lots,
|
|
max_base_lots: 1,
|
|
..PerpPlaceOrderInstruction::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpPlaceOrderInstruction {
|
|
account: account_1,
|
|
perp_market,
|
|
owner,
|
|
side: Side::Ask,
|
|
price_lots,
|
|
max_base_lots: 1,
|
|
..PerpPlaceOrderInstruction::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpConsumeEventsInstruction {
|
|
perp_market,
|
|
mango_accounts: vec![account_0, account_1],
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
// Manipulate the price (without adjusting stable price)
|
|
let price_factor = 3;
|
|
send_tx(
|
|
solana,
|
|
StubOracleSetInstruction {
|
|
oracle: tokens[1].oracle,
|
|
group,
|
|
admin,
|
|
mint: mints[1].pubkey,
|
|
price: price_factor as f64 * 1000.0,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
//
|
|
// Test 1: settle max possible, limited by unrealized pnl settle limit
|
|
//
|
|
// a has lots of positive unrealized pnl, b has negative unrealized pnl.
|
|
// Since b has very large deposits, b's health will not interfere.
|
|
// The pnl settle limit is relative to the stable price
|
|
let market = solana.get_account::<PerpMarket>(perp_market).await;
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
let account_1_settle_limits = mango_account_1.perps[0].available_settle_limit(&market);
|
|
assert_eq!(account_1_settle_limits, (-80000, 80000));
|
|
let account_1_settle_limit = I80F48::from(account_1_settle_limits.0.abs());
|
|
assert_eq!(
|
|
account_1_settle_limit,
|
|
(market.settle_pnl_limit_factor()
|
|
* market.stable_price()
|
|
* mango_account_0.perps[0].base_position_native(&market))
|
|
.round()
|
|
);
|
|
let mango_account_1_expected_qpn_after_settle =
|
|
mango_account_1.perps[0].quote_position_native() + account_1_settle_limit.round();
|
|
send_tx(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_1,
|
|
perp_market,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
assert_eq!(
|
|
mango_account_1.perps[0].quote_position_native().round(),
|
|
mango_account_1_expected_qpn_after_settle.round()
|
|
);
|
|
// neither account has any settle limit left
|
|
assert_eq!(
|
|
mango_account_0.perps[0].available_settle_limit(&market).1,
|
|
0
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0].available_settle_limit(&market).0,
|
|
0
|
|
);
|
|
|
|
//
|
|
// Test 2: Once the settle limit is exhausted, we can't settle more
|
|
//
|
|
// we are in the same window, and we settled max. possible in previous attempt
|
|
send_tx_expect_error!(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_1,
|
|
perp_market,
|
|
},
|
|
MangoError::ProfitabilityMismatch
|
|
);
|
|
|
|
//
|
|
// Test 3: realizing the pnl does not allow further settling
|
|
//
|
|
send_tx(
|
|
solana,
|
|
PerpPlaceOrderInstruction {
|
|
account: account_1,
|
|
perp_market,
|
|
owner,
|
|
side: Side::Bid,
|
|
price_lots: 3 * price_lots,
|
|
max_base_lots: 1,
|
|
..PerpPlaceOrderInstruction::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpPlaceOrderInstruction {
|
|
account: account_0,
|
|
perp_market,
|
|
owner,
|
|
side: Side::Ask,
|
|
price_lots: 3 * price_lots,
|
|
max_base_lots: 1,
|
|
..PerpPlaceOrderInstruction::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpConsumeEventsInstruction {
|
|
perp_market,
|
|
mango_accounts: vec![account_0, account_1],
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
// neither account has any settle limit left (check for 1 because of the ceil()ing)
|
|
assert_eq!(
|
|
mango_account_0.perps[0].available_settle_limit(&market).1,
|
|
1
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0].available_settle_limit(&market).0,
|
|
-1
|
|
);
|
|
// check that realized pnl settle limit was set up correctly
|
|
assert_eq!(
|
|
mango_account_0.perps[0].recurring_settle_pnl_allowance,
|
|
(0.8 * 1.0 * 100.0 * 1000.0) as i64 + 1
|
|
); // +1 just for rounding
|
|
|
|
// settle 1
|
|
let account_1_quote_before = mango_account_1.perps[0].quote_position_native();
|
|
send_tx(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_1,
|
|
perp_market,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
// indeed settled 1
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
assert_eq!(
|
|
mango_account_1.perps[0].quote_position_native() - account_1_quote_before,
|
|
I80F48::from(1)
|
|
);
|
|
|
|
//
|
|
// Test 4: Move to a new settle window and check the realized pnl settle limit
|
|
//
|
|
// This time account 0's realized pnl settle limit kicks in.
|
|
//
|
|
let account_1_quote_before = mango_account_1.perps[0].quote_position_native();
|
|
let account_0_realized_limit = mango_account_0.perps[0].recurring_settle_pnl_allowance;
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpSetSettleLimitWindow {
|
|
group,
|
|
admin,
|
|
perp_market,
|
|
window_size_ts: 10000, // guaranteed to move windows, resetting the limits
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_1,
|
|
perp_market,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
// successful settle of expected amount
|
|
assert_eq!(
|
|
mango_account_1.perps[0].quote_position_native() - account_1_quote_before,
|
|
I80F48::from(account_0_realized_limit)
|
|
);
|
|
// account0's limit gets reduced to the pnl amount left over
|
|
let perp_market_data = solana.get_account::<PerpMarket>(perp_market).await;
|
|
assert_eq!(
|
|
mango_account_0.perps[0].recurring_settle_pnl_allowance,
|
|
mango_account_0.perps[0]
|
|
.unsettled_pnl(&perp_market_data, I80F48::from_num(1.0))
|
|
.unwrap()
|
|
);
|
|
|
|
// can't settle again
|
|
assert!(send_tx(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_1,
|
|
perp_market,
|
|
},
|
|
)
|
|
.await
|
|
.is_err());
|
|
|
|
//
|
|
// Test 5: in a new settle window, the remaining pnl can be settled
|
|
//
|
|
|
|
let account_1_quote_before = mango_account_1.perps[0].quote_position_native();
|
|
let account_0_realized_limit = mango_account_0.perps[0].recurring_settle_pnl_allowance;
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpSetSettleLimitWindow {
|
|
group,
|
|
admin,
|
|
perp_market,
|
|
window_size_ts: 5000, // guaranteed to move windows, resetting the limits
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
send_tx(
|
|
solana,
|
|
PerpSettlePnlInstruction {
|
|
settler,
|
|
settler_owner,
|
|
account_a: account_0,
|
|
account_b: account_1,
|
|
perp_market,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
let mango_account_0 = solana.get_account::<MangoAccount>(account_0).await;
|
|
let mango_account_1 = solana.get_account::<MangoAccount>(account_1).await;
|
|
// successful settle of expected amount
|
|
assert_eq!(
|
|
mango_account_1.perps[0].quote_position_native() - account_1_quote_before,
|
|
I80F48::from(account_0_realized_limit)
|
|
);
|
|
// account0's limit gets reduced to the realized pnl amount left over
|
|
assert_eq!(mango_account_0.perps[0].recurring_settle_pnl_allowance, 0);
|
|
assert_eq!(
|
|
mango_account_0.perps[0].realized_pnl_for_position_native,
|
|
I80F48::from(0)
|
|
);
|
|
assert_eq!(
|
|
mango_account_1.perps[0].realized_pnl_for_position_native,
|
|
I80F48::from(0)
|
|
);
|
|
|
|
Ok(())
|
|
}
|