use std::collections::HashMap;
use std::sync::Arc;
use starknet::core::types::Felt;
use tokio::sync::mpsc;
use tracing::{debug, error, info};
use crate::app::actions::Action;
use crate::data::DataSource;
use crate::data::pathfinder::PathfinderClient;
use crate::data::types::SnTransaction;
use crate::decode::AbiRegistry;
use crate::decode::abi::ParsedAbi;
use crate::decode::events::decode_event;
use crate::decode::functions::parse_multicall;
use crate::decode::outside_execution::{
OutsideExecutionInfo, OutsideExecutionVersion, is_avnu_forwarder, is_outside_execution,
looks_like_outside_execution, looks_like_private_sponsored, parse_forwarder_call,
parse_outside_execution, parse_private_sponsored,
};
async fn abi_at_block(
addr: &Felt,
block: u64,
addr_to_class: &HashMap<Felt, Felt>,
ds: &Arc<dyn DataSource>,
pf: Option<&Arc<PathfinderClient>>,
abi_reg: &AbiRegistry,
) -> Option<Arc<ParsedAbi>> {
if let Some(class_hash) = addr_to_class.get(addr) {
return abi_reg.get_abi_for_class(class_hash).await;
}
if block > 0
&& let Some(class_hash) = super::helpers::resolve_class_hash_at(*addr, block, ds, pf).await
{
return abi_reg.get_abi_for_class(&class_hash).await;
}
abi_reg.get_abi_for_address(addr).await
}
pub(super) async fn resolve_call_abis(
calls: &mut [crate::decode::functions::RawCall],
block: u64,
addr_to_class: &HashMap<Felt, Felt>,
ds: &Arc<dyn DataSource>,
pf: Option<&Arc<PathfinderClient>>,
abi_reg: &Arc<AbiRegistry>,
) {
use futures::stream::StreamExt;
let abi_futs: Vec<_> = calls
.iter()
.map(|call| {
abi_at_block(
&call.contract_address,
block,
addr_to_class,
ds,
pf,
abi_reg,
)
})
.collect();
let abis: Vec<Option<Arc<ParsedAbi>>> =
futures::stream::iter(abi_futs).buffered(8).collect().await;
for (call, abi_opt) in calls.iter_mut().zip(abis.into_iter()) {
if let Some(name) = abi_reg.get_selector_name(&call.selector) {
call.function_name = Some(name);
}
if let Some(abi) = abi_opt {
if let Some(func) = abi.get_function(&call.selector) {
if call.function_name.is_none() {
call.function_name = Some(func.name.clone());
}
call.function_def = Some(func.clone());
}
call.contract_abi = Some(abi);
}
}
}
pub(super) async fn decode_and_send_transaction(
transaction: SnTransaction,
receipt: crate::data::types::SnReceipt,
ds: &Arc<dyn DataSource>,
pf: Option<&Arc<PathfinderClient>>,
abi_reg: &Arc<AbiRegistry>,
action_tx: &mpsc::UnboundedSender<Action>,
) {
let block = receipt.block_number;
let mut decoded_calls = match &transaction {
SnTransaction::Invoke(invoke) => parse_multicall(&invoke.calldata),
_ => Vec::new(),
};
let mut prewarm_targets: std::collections::HashSet<Felt> =
std::collections::HashSet::with_capacity(receipt.events.len() + decoded_calls.len());
for event in &receipt.events {
prewarm_targets.insert(event.from_address);
}
for call in &decoded_calls {
prewarm_targets.insert(call.contract_address);
}
let addr_to_class = if block > 0 {
super::helpers::prewarm_abis_at(prewarm_targets, block, ds, pf, abi_reg).await
} else {
super::helpers::prewarm_abis(prewarm_targets, abi_reg).await;
HashMap::new()
};
use futures::stream::StreamExt;
let decoded_events: Vec<_> = {
let addr_to_class = &addr_to_class;
let event_futs: Vec<_> = receipt
.events
.iter()
.map(|event| async move {
let abi =
abi_at_block(&event.from_address, block, addr_to_class, ds, pf, abi_reg).await;
decode_event(event, abi.as_deref())
})
.collect();
futures::stream::iter(event_futs)
.buffered(8)
.collect()
.await
};
resolve_call_abis(&mut decoded_calls, block, &addr_to_class, ds, pf, abi_reg).await;
let outside_executions = detect_and_resolve_outside_executions(
&decoded_calls,
block,
&addr_to_class,
ds,
pf,
abi_reg,
)
.await;
let block_info = ds.get_block(block).await.ok();
let block_timestamp = block_info.as_ref().map(|b| b.timestamp);
let block_gas_prices_fri = block_info.as_ref().map(|b| {
(
b.l1_gas_price_fri,
b.l2_gas_price_fri,
b.l1_data_gas_price_fri,
)
});
let block_status = block_info.as_ref().map(|b| b.status.clone());
let tx_hash = transaction.hash();
let _ = action_tx.send(Action::TransactionLoaded {
transaction,
receipt,
decoded_events,
decoded_calls,
outside_executions,
block_timestamp,
block_gas_prices_fri,
block_status,
});
spawn_trace_fetch(tx_hash, block, ds, abi_reg, action_tx);
}
async fn detect_and_resolve_outside_executions(
calls: &[crate::decode::functions::RawCall],
block: u64,
addr_to_class: &HashMap<Felt, Felt>,
ds: &Arc<dyn DataSource>,
pf: Option<&Arc<PathfinderClient>>,
abi_reg: &Arc<AbiRegistry>,
) -> Vec<(usize, OutsideExecutionInfo)> {
let mut detected: Vec<(usize, OutsideExecutionInfo)> = Vec::new();
for (i, call) in calls.iter().enumerate() {
let fname = call.function_name.as_deref().unwrap_or("");
let mut oe = None;
if let Some(version) = is_outside_execution(fname) {
oe = if matches!(version, OutsideExecutionVersion::PrivateSponsored) {
parse_private_sponsored(call)
} else {
parse_outside_execution(call, version)
};
}
if oe.is_none() && looks_like_private_sponsored(call) {
oe = parse_private_sponsored(call);
}
if oe.is_none() && fname.is_empty() && looks_like_outside_execution(call) {
oe = parse_outside_execution(call, OutsideExecutionVersion::V2);
}
if oe.is_none() && is_avnu_forwarder(&call.contract_address) {
oe = parse_forwarder_call(call);
}
if let Some(oe) = oe {
detected.push((i, oe));
}
}
let resolve_futs = detected.iter_mut().map(|(_, oe)| {
resolve_call_abis(&mut oe.inner_calls, block, addr_to_class, ds, pf, abi_reg)
});
futures::future::join_all(resolve_futs).await;
detected
}
pub(super) async fn fetch_and_send_transaction(
hash: starknet::core::types::Felt,
ds: &Arc<dyn DataSource>,
pf: Option<&Arc<PathfinderClient>>,
abi_reg: &Arc<AbiRegistry>,
tx: &mpsc::UnboundedSender<Action>,
) {
let start = std::time::Instant::now();
let hash_short = format!("{:#x}", hash);
debug!(tx_hash = %hash_short, "Fetching transaction + receipt");
let ds2 = Arc::clone(ds);
let (tx_result, receipt_result) = tokio::join!(ds.get_transaction(hash), ds2.get_receipt(hash));
match (tx_result, receipt_result) {
(Ok(transaction), Ok(receipt)) => {
info!(tx_hash = %hash_short, elapsed_ms = start.elapsed().as_millis(), "Transaction fetched, decoding");
decode_and_send_transaction(transaction, receipt, ds, pf, abi_reg, tx).await;
}
(Err(e), _) | (_, Err(e)) => {
error!(tx_hash = %hash_short, elapsed_ms = start.elapsed().as_millis(), error = %e, "Failed to fetch transaction");
let _ = tx.send(Action::Error(format!("Fetch tx: {e}")));
}
}
}
pub(super) async fn fetch_and_send_trace(
hash: starknet::core::types::Felt,
block: u64,
ds: Arc<dyn DataSource>,
abi_reg: Arc<AbiRegistry>,
tx: mpsc::UnboundedSender<Action>,
) {
let start = std::time::Instant::now();
let hash_short = format!("{:#x}", hash);
debug!(tx_hash = %hash_short, "Fetching transaction trace");
match ds.get_trace(hash).await {
Ok(trace) => {
let decoded = crate::decode::trace::decode_trace(&trace, hash, block, &abi_reg).await;
info!(
tx_hash = %hash_short,
elapsed_ms = start.elapsed().as_millis(),
"Trace fetched + decoded"
);
let _ = tx.send(Action::TransactionTraceLoaded {
tx_hash: hash,
trace: Some(decoded),
});
}
Err(e) => {
error!(tx_hash = %hash_short, error = %e, "Failed to fetch trace");
let _ = tx.send(Action::TransactionTraceLoaded {
tx_hash: hash,
trace: None,
});
let _ = tx.send(Action::Error(format!("Fetch trace: {e}")));
}
}
}
pub(super) fn spawn_trace_fetch(
hash: starknet::core::types::Felt,
block: u64,
ds: &Arc<dyn DataSource>,
abi_reg: &Arc<AbiRegistry>,
tx: &mpsc::UnboundedSender<Action>,
) {
let ds = Arc::clone(ds);
let abi_reg = Arc::clone(abi_reg);
let tx = tx.clone();
tokio::spawn(async move {
fetch_and_send_trace(hash, block, ds, abi_reg, tx).await;
});
}