213 lines
7.4 KiB
Rust
213 lines
7.4 KiB
Rust
use std::{collections::HashMap, str::FromStr};
|
|
|
|
use crate::account_shared_data::KeyedAccountSharedData;
|
|
|
|
use client::MangoClient;
|
|
use mango_v4::accounts_zerocopy::LoadZeroCopy;
|
|
use mango_v4::state::{
|
|
compute_health, oracle_price, Bank, FixedOrderAccountRetriever, HealthType, MangoAccount,
|
|
MintInfo, PerpMarketIndex, TokenIndex,
|
|
};
|
|
|
|
use {
|
|
crate::chain_data::ChainData, anyhow::Context, fixed::types::I80F48, log::*,
|
|
solana_sdk::account::AccountSharedData, solana_sdk::pubkey::Pubkey,
|
|
};
|
|
|
|
pub fn load_mango_account<T: anchor_lang::ZeroCopy + anchor_lang::Owner>(
|
|
account: &AccountSharedData,
|
|
) -> anyhow::Result<&T> {
|
|
account.load::<T>().map_err(|e| e.into())
|
|
}
|
|
|
|
fn load_mango_account_from_chain<'a, T: anchor_lang::ZeroCopy + anchor_lang::Owner>(
|
|
chain_data: &'a ChainData,
|
|
pubkey: &Pubkey,
|
|
) -> anyhow::Result<&'a T> {
|
|
load_mango_account::<T>(
|
|
chain_data
|
|
.account(pubkey)
|
|
.context("retrieving account from chain")?,
|
|
)
|
|
}
|
|
|
|
pub fn compute_health_(
|
|
chain_data: &ChainData,
|
|
mint_infos: &HashMap<TokenIndex, Pubkey>,
|
|
perp_markets: &HashMap<PerpMarketIndex, Pubkey>,
|
|
account: &MangoAccount,
|
|
health_type: HealthType,
|
|
) -> anchor_lang::Result<I80F48> {
|
|
let mut health_accounts = vec![];
|
|
let mut banks = vec![];
|
|
let mut oracles = vec![];
|
|
|
|
// collect banks and oracles for active token positions
|
|
for position in account.tokens.iter_active() {
|
|
let mint_info = load_mango_account_from_chain::<MintInfo>(
|
|
chain_data,
|
|
mint_infos
|
|
.get(&position.token_index)
|
|
.expect("mint_infos cache missing entry"),
|
|
)
|
|
.unwrap();
|
|
|
|
banks.push((
|
|
mint_info.first_bank(),
|
|
chain_data
|
|
.account(&mint_info.first_bank())
|
|
.expect("chain data is missing bank"),
|
|
));
|
|
oracles.push((
|
|
mint_info.oracle,
|
|
chain_data
|
|
.account(&mint_info.oracle)
|
|
.expect("chain data is missing oracle"),
|
|
));
|
|
}
|
|
|
|
// collect active perp markets
|
|
let mut perp_markets = account
|
|
.perps
|
|
.iter_active_accounts()
|
|
.map(|&s| {
|
|
(
|
|
*perp_markets
|
|
.get(&s.market_index)
|
|
.expect("perp markets cache is missing entry"),
|
|
chain_data
|
|
.account(
|
|
perp_markets
|
|
.get(&s.market_index)
|
|
.expect("perp markets cache is missing entry"),
|
|
)
|
|
.expect("chain data is missing perp market"),
|
|
)
|
|
})
|
|
.collect::<Vec<(Pubkey, &AccountSharedData)>>();
|
|
let active_perp_len = perp_markets.len();
|
|
|
|
// collect OO for active serum markets
|
|
let mut serum_oos = account
|
|
.serum3
|
|
.iter_active()
|
|
.map(|&s| (s.open_orders, chain_data.account(&s.open_orders).unwrap()))
|
|
.collect::<Vec<(Pubkey, &AccountSharedData)>>();
|
|
|
|
let active_token_len = banks.len();
|
|
health_accounts.append(&mut banks);
|
|
health_accounts.append(&mut oracles);
|
|
health_accounts.append(&mut perp_markets);
|
|
health_accounts.append(&mut serum_oos);
|
|
|
|
let retriever = FixedOrderAccountRetriever {
|
|
ais: health_accounts
|
|
.into_iter()
|
|
.map(|asd| KeyedAccountSharedData::new(asd.0, asd.1.clone()))
|
|
.collect::<Vec<_>>(),
|
|
n_banks: active_token_len,
|
|
begin_perp: active_token_len * 2,
|
|
begin_serum3: active_token_len * 2 + active_perp_len,
|
|
};
|
|
compute_health(account, health_type, &retriever)
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub fn process_accounts<'a>(
|
|
mango_client: &MangoClient,
|
|
chain_data: &ChainData,
|
|
accounts: impl Iterator<Item = &'a Pubkey>,
|
|
mint_infos: &HashMap<TokenIndex, Pubkey>,
|
|
perp_markets: &HashMap<PerpMarketIndex, Pubkey>,
|
|
) -> anyhow::Result<()> {
|
|
for pubkey in accounts {
|
|
let account_result = load_mango_account_from_chain::<MangoAccount>(chain_data, pubkey);
|
|
let account = match account_result {
|
|
Ok(account) => account,
|
|
Err(err) => {
|
|
warn!("could not load account {}: {:?}", pubkey, err);
|
|
continue;
|
|
}
|
|
};
|
|
|
|
// compute maint health for account
|
|
let maint_health = compute_health_(
|
|
chain_data,
|
|
mint_infos,
|
|
perp_markets,
|
|
account,
|
|
HealthType::Maint,
|
|
)
|
|
.expect("always ok");
|
|
|
|
// try liquidating
|
|
if maint_health.is_negative() {
|
|
// find asset and liab tokens
|
|
let mut tokens = account
|
|
.tokens
|
|
.iter_active()
|
|
.map(|token| {
|
|
let mint_info_pk = mint_infos.get(&token.token_index).expect("always Ok");
|
|
let mint_info =
|
|
load_mango_account_from_chain::<MintInfo>(chain_data, mint_info_pk)?;
|
|
let bank =
|
|
load_mango_account_from_chain::<Bank>(chain_data, &mint_info.first_bank())?;
|
|
let oracle = chain_data.account(&mint_info.oracle)?;
|
|
let price = oracle_price(
|
|
&KeyedAccountSharedData::new(mint_info.oracle, oracle.clone()),
|
|
bank.oracle_config.conf_filter,
|
|
bank.mint_decimals,
|
|
)?;
|
|
Ok((token.token_index, bank, token.native(bank) * price))
|
|
})
|
|
.collect::<anyhow::Result<Vec<(TokenIndex, &Bank, I80F48)>>>()?;
|
|
tokens.sort_by(|a, b| a.2.cmp(&b.2));
|
|
if tokens.len() < 2 {
|
|
anyhow::bail!(format!(
|
|
"mango account {}, has less than 2 active tokens",
|
|
pubkey
|
|
));
|
|
}
|
|
let (asset_token_index, _asset_bank, _asset_price) = tokens.last().unwrap();
|
|
let (liab_token_index, _liab_bank, _liab_price) = tokens.first().unwrap();
|
|
|
|
//
|
|
// TODO: log liqor's assets in UI form
|
|
// TODO: log liquee's liab_needed, need to refactor program code to be able to be accessed from client side
|
|
// TODO: swap inherited liabs to desired asset for liqor
|
|
//
|
|
let sig = mango_client.liq_token_with_token(
|
|
(pubkey, account),
|
|
*asset_token_index,
|
|
*liab_token_index,
|
|
{
|
|
// max liab liqor can provide
|
|
// let fresh_liqor = load_mango_account_from_chain::<MangoAccount>(
|
|
// chain_data,
|
|
// &mango_client.mango_account_cache.0,
|
|
// )?;
|
|
// fresh_liqor
|
|
// .tokens
|
|
// .find(*liab_token_index)
|
|
// .unwrap()
|
|
// .native(&_liab_bank)
|
|
I80F48::from_str("0.0000001").unwrap()
|
|
},
|
|
);
|
|
match sig {
|
|
Ok(sig) => log::info!(
|
|
"Liquidated {}..., maint_health was {}, tx sig {:?}",
|
|
&pubkey.to_string()[..3],
|
|
maint_health,
|
|
sig
|
|
),
|
|
Err(err) => {
|
|
log::error!("{:?}", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|