255 lines
11 KiB
Rust
255 lines
11 KiB
Rust
use bytemuck::cast_ref;
|
|
use serum_dex::{instruction::MarketInstruction, state::EventView};
|
|
use solana_geyser_connector_lib::{
|
|
chain_data::{AccountData, ChainData, SlotData},
|
|
metrics::Metrics,
|
|
serum::SerumEventQueueHeader,
|
|
AccountWrite, SlotUpdate,
|
|
};
|
|
|
|
use anchor_lang::AccountDeserialize;
|
|
use log::*;
|
|
use solana_sdk::{
|
|
account::{ReadableAccount, WritableAccount},
|
|
instruction::{AccountMeta, Instruction},
|
|
pubkey::Pubkey,
|
|
stake_history::Epoch,
|
|
};
|
|
use std::{
|
|
borrow::BorrowMut,
|
|
collections::{BTreeSet, HashMap, HashSet},
|
|
convert::TryFrom,
|
|
str::FromStr,
|
|
};
|
|
|
|
pub fn init(
|
|
perp_queue_pks: Vec<(Pubkey, Pubkey)>,
|
|
serum_queue_pks: Vec<(Pubkey, Pubkey)>,
|
|
group_pk: Pubkey,
|
|
metrics_sender: Metrics,
|
|
) -> anyhow::Result<(
|
|
async_channel::Sender<AccountWrite>,
|
|
async_channel::Sender<SlotUpdate>,
|
|
async_channel::Receiver<Vec<Instruction>>,
|
|
)> {
|
|
let metrics_sender = metrics_sender.clone();
|
|
|
|
// The actual message may want to also contain a retry count, if it self-reinserts on failure?
|
|
let (account_write_queue_sender, account_write_queue_receiver) =
|
|
async_channel::unbounded::<AccountWrite>();
|
|
|
|
// Slot updates flowing from the outside into the single processing thread. From
|
|
// there they'll flow into the postgres sending thread.
|
|
let (slot_queue_sender, slot_queue_receiver) = async_channel::unbounded::<SlotUpdate>();
|
|
|
|
// Event queue updates can be consumed by client connections
|
|
let (instruction_sender, instruction_receiver) = async_channel::unbounded::<Vec<Instruction>>();
|
|
|
|
let mut chain_cache = ChainData::new(metrics_sender);
|
|
let mut last_evq_versions = HashMap::<String, (u64, u64)>::new();
|
|
|
|
let all_queue_pks: HashSet<Pubkey> = perp_queue_pks
|
|
.iter()
|
|
.chain(serum_queue_pks.iter())
|
|
.map(|mkt| mkt.1)
|
|
.collect();
|
|
|
|
// update handling thread, reads both sloths and account updates
|
|
tokio::spawn(async move {
|
|
loop {
|
|
tokio::select! {
|
|
Ok(account_write) = account_write_queue_receiver.recv() => {
|
|
if !all_queue_pks.contains(&account_write.pubkey) {
|
|
continue;
|
|
}
|
|
|
|
chain_cache.update_account(
|
|
account_write.pubkey,
|
|
AccountData {
|
|
slot: account_write.slot,
|
|
write_version: account_write.write_version,
|
|
account: WritableAccount::create(
|
|
account_write.lamports,
|
|
account_write.data.clone(),
|
|
account_write.owner,
|
|
account_write.executable,
|
|
account_write.rent_epoch as Epoch,
|
|
),
|
|
},
|
|
);
|
|
}
|
|
Ok(slot_update) = slot_queue_receiver.recv() => {
|
|
chain_cache.update_slot(SlotData {
|
|
slot: slot_update.slot,
|
|
parent: slot_update.parent,
|
|
status: slot_update.status,
|
|
chain: 0,
|
|
});
|
|
|
|
}
|
|
}
|
|
|
|
for (mkt_pk, evq_pk) in perp_queue_pks.iter() {
|
|
let evq_b58 = evq_pk.to_string();
|
|
let last_evq_version = last_evq_versions.get(&evq_b58).unwrap_or(&(0, 0));
|
|
|
|
match chain_cache.account(&evq_pk) {
|
|
Ok(account_info) => {
|
|
// only process if the account state changed
|
|
let evq_version = (account_info.slot, account_info.write_version);
|
|
trace!("mango perp evq={evq_b58} write_version={:?}", evq_version);
|
|
if evq_version == *last_evq_version {
|
|
continue;
|
|
}
|
|
last_evq_versions.insert(evq_b58.clone(), evq_version);
|
|
|
|
let account = &account_info.account;
|
|
|
|
let event_queue: mango_v4::state::EventQueue =
|
|
mango_v4::state::EventQueue::try_deserialize(
|
|
account.data().borrow_mut(),
|
|
)
|
|
.unwrap();
|
|
|
|
if !event_queue.is_empty() {
|
|
let mango_accounts: BTreeSet<_> = event_queue
|
|
.iter()
|
|
.take(10)
|
|
.flat_map(|e| {
|
|
match mango_v4::state::EventType::try_from(e.event_type)
|
|
.expect("mango v4 event")
|
|
{
|
|
mango_v4::state::EventType::Fill => {
|
|
let fill: &mango_v4::state::FillEvent = cast_ref(e);
|
|
vec![fill.maker, fill.taker]
|
|
}
|
|
mango_v4::state::EventType::Out => {
|
|
let out: &mango_v4::state::OutEvent = cast_ref(e);
|
|
vec![out.owner]
|
|
}
|
|
mango_v4::state::EventType::Liquidate => vec![],
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
let mut ams: Vec<_> = anchor_lang::ToAccountMetas::to_account_metas(
|
|
&mango_v4::accounts::PerpConsumeEvents {
|
|
group: group_pk,
|
|
perp_market: *mkt_pk,
|
|
event_queue: *evq_pk,
|
|
},
|
|
None,
|
|
);
|
|
ams.append(
|
|
&mut mango_accounts
|
|
.iter()
|
|
.map(|pk| AccountMeta::new(*pk, false))
|
|
.collect(),
|
|
);
|
|
|
|
let ix = Instruction {
|
|
program_id: mango_v4::id(),
|
|
accounts: ams,
|
|
data: anchor_lang::InstructionData::data(
|
|
&mango_v4::instruction::PerpConsumeEvents { limit: 10 },
|
|
),
|
|
};
|
|
|
|
info!(
|
|
"mango perp evq={evq_b58} count={} limit=10",
|
|
event_queue.iter().count()
|
|
);
|
|
instruction_sender.send(vec![ix]).await;
|
|
}
|
|
}
|
|
Err(_) => info!("chain_cache could not find {evq_b58}"),
|
|
}
|
|
}
|
|
|
|
for (mkt_pk, evq_pk) in serum_queue_pks.iter() {
|
|
let evq_b58 = evq_pk.to_string();
|
|
let last_evq_version = last_evq_versions.get(&evq_b58).unwrap_or(&(0, 0));
|
|
|
|
match chain_cache.account(&evq_pk) {
|
|
Ok(account_info) => {
|
|
// only process if the account state changed
|
|
let evq_version = (account_info.slot, account_info.write_version);
|
|
trace!("serum evq={evq_b58} write_version={:?}", evq_version);
|
|
if evq_version == *last_evq_version {
|
|
continue;
|
|
}
|
|
last_evq_versions.insert(evq_b58.clone(), evq_version);
|
|
|
|
let account = &account_info.account;
|
|
|
|
let inner_data = &account.data()[5..&account.data().len() - 7];
|
|
let header_span = std::mem::size_of::<SerumEventQueueHeader>();
|
|
let header: SerumEventQueueHeader =
|
|
*bytemuck::from_bytes(&inner_data[..header_span]);
|
|
let count = header.count;
|
|
|
|
if count > 0 {
|
|
let rest = &inner_data[header_span..];
|
|
let event_size = std::mem::size_of::<serum_dex::state::Event>();
|
|
let slop = rest.len() % event_size;
|
|
let end = rest.len() - slop;
|
|
let events =
|
|
bytemuck::cast_slice::<u8, serum_dex::state::Event>(&rest[..end]);
|
|
let seq_num = header.seq_num;
|
|
|
|
let oo_pks: BTreeSet<_> = (0..count)
|
|
.map(|i| {
|
|
let offset = (seq_num - count + i) % events.len() as u64;
|
|
let event: serum_dex::state::Event = events[offset as usize];
|
|
let oo_pk = match event.as_view().unwrap() {
|
|
EventView::Fill { owner, .. }
|
|
| EventView::Out { owner, .. } => {
|
|
bytemuck::cast_slice::<u64, Pubkey>(&owner)[0]
|
|
}
|
|
};
|
|
oo_pk
|
|
})
|
|
.collect();
|
|
|
|
let mut ams: Vec<_> = oo_pks
|
|
.iter()
|
|
.map(|pk| AccountMeta::new(*pk, false))
|
|
.collect();
|
|
|
|
// pass two times evq_pk instead of deprecated fee receivers to reduce encoded tx size
|
|
ams.append(
|
|
&mut [
|
|
mkt_pk, evq_pk, evq_pk, /*coin_pk*/
|
|
evq_pk, /*pc_pk*/
|
|
]
|
|
.iter()
|
|
.map(|pk| AccountMeta::new(**pk, false))
|
|
.collect(),
|
|
);
|
|
|
|
let ix = Instruction {
|
|
program_id: Pubkey::from_str(
|
|
"srmqPvymJeFKQ4zGQed1GFppgkRHL9kaELCbyksJtPX",
|
|
)
|
|
.unwrap(),
|
|
accounts: ams,
|
|
data: MarketInstruction::ConsumeEvents(count as u16).pack(),
|
|
};
|
|
|
|
info!("serum evq={evq_b58} count={count}");
|
|
instruction_sender.send(vec![ix]).await;
|
|
}
|
|
}
|
|
Err(_) => info!("chain_cache could not find {evq_b58}"),
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
Ok((
|
|
account_write_queue_sender,
|
|
slot_queue_sender,
|
|
instruction_receiver,
|
|
))
|
|
}
|