use std::collections::{HashMap, HashSet};
use starknet::core::types::Felt;
use crate::app::AddressTab;
use crate::app::actions::Source;
use crate::app::state::TxNavItem;
use crate::data::types::{
AddressTxSummary, ContractCallSummary, MetaTxIntenderSummary, SnAddressInfo, TokenTransfer,
};
use crate::decode::events::DecodedEvent;
use crate::network::dune::AddressActivityProbe;
use crate::ui::widgets::address_color::AddressColorMap;
use crate::ui::widgets::stateful_list::StatefulList;
pub const SMALL_GAP_SPAN_BLOCKS: u64 = 50;
pub const LARGE_GAP_FILL_CHUNK_TXS: u32 = 50;
pub const AUTO_FILL_MAX_MISSING: u64 = 1;
pub const MAX_AUTO_FILLS_PER_REFRESH: usize = 5;
#[derive(Clone, Debug, Default)]
pub struct EventWindowHint {
pub min_searched: u64,
pub max_searched: u64,
pub deferred_gap: Option<(u64, u64)>,
}
#[derive(Clone, Debug)]
pub struct UnfilledGap {
pub lo_nonce: u64,
pub hi_nonce: u64,
pub lo_block: u64,
pub hi_block: u64,
pub missing_count: u64,
pub fill_dispatched: bool,
}
pub const CALL_GAP_SPAN_BLOCKS: u64 = 10_000;
#[derive(Clone, Debug)]
pub struct UnfilledCallGap {
pub lo_block: u64,
pub hi_block: u64,
pub fill_dispatched: bool,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TransferGap {
pub lo_block: u64,
pub hi_block: u64,
pub fill_dispatched: bool,
}
pub fn scanned_range_gaps(ranges: &[(u64, u64)], floor: u64) -> Vec<TransferGap> {
let mut out = Vec::new();
let Some(&(min_lo, _)) = ranges.first() else {
return out;
};
if min_lo > floor {
out.push(TransferGap {
lo_block: floor,
hi_block: min_lo - 1,
fill_dispatched: false,
});
}
for w in ranges.windows(2) {
let (a_hi, b_lo) = (w[0].1, w[1].0);
if b_lo > a_hi + 1 {
out.push(TransferGap {
lo_block: a_hi + 1,
hi_block: b_lo - 1,
fill_dispatched: false,
});
}
}
out
}
pub struct AddressInfoState {
pub info: Option<SnAddressInfo>,
pub events: StatefulList<DecodedEvent>,
pub txs: StatefulList<AddressTxSummary>,
pub deployment: Option<AddressTxSummary>,
pub calls: StatefulList<ContractCallSummary>,
pub call_blocks: HashMap<Felt, u64>,
pub is_contract: bool,
pub not_deployed: bool,
pub visual_mode: bool,
pub nav_items: Vec<TxNavItem>,
pub nav_cursor: usize,
pub class_history: Vec<crate::data::pathfinder::ClassHashEntry>,
pub class_history_scroll: usize,
pub tab: AddressTab,
pub context: Option<Felt>,
pub fetching_more_txs: bool,
pub oldest_event_block: Option<u64>,
pub sources_pending: HashSet<Source>,
pub activity_probe: Option<AddressActivityProbe>,
pub dune_cursor_block: Option<u64>,
pub rpc_cursor_block: Option<u64>,
pub dune_has_more: bool,
pub rpc_has_more: bool,
pub ws_subscribed: bool,
pub sanity_check_dispatched: bool,
pub unfilled_gaps: Vec<UnfilledGap>,
pub gap_selected: Option<u64>,
pub txs_render_state: ratatui::widgets::ListState,
pub call_gaps: Vec<UnfilledCallGap>,
pub call_gap_selected: Option<u64>,
pub calls_render_state: ratatui::widgets::ListState,
pub scanned_call_ranges: Vec<(u64, u64)>,
pub call_tracked_from: Option<u64>,
pub transfers: StatefulList<TokenTransfer>,
pub transfer_keys: HashMap<(Felt, u64), u64>,
pub transfer_scanned_ranges: Vec<(u64, u64)>,
pub transfer_gaps: Vec<TransferGap>,
pub transfer_gap_selected: Option<u64>,
pub transfers_render_state: ratatui::widgets::ListState,
pub transfers_dispatched: bool,
pub fetching_transfers: bool,
pub transfer_color_map: AddressColorMap,
pub transfer_counts: HashMap<Felt, usize>,
pub transfer_color_processed_len: usize,
pub meta_txs: StatefulList<MetaTxIntenderSummary>,
pub fetching_meta_txs: bool,
pub meta_tx_cursor_block: Option<u64>,
pub meta_tx_has_more: bool,
pub meta_txs_dispatched: bool,
pub meta_tx_from_block: u64,
pub meta_tx_last_window: u64,
pub event_window: Option<EventWindowHint>,
pub call_sender_counts: HashMap<Felt, usize>,
pub call_color_map: AddressColorMap,
pub call_color_processed_len: usize,
pub tx_contract_counts: HashMap<Felt, usize>,
pub tx_color_map: AddressColorMap,
pub tx_color_processed_len: usize,
}
pub const AUTO_FILL_TARGET: usize = 50;
impl Default for AddressInfoState {
fn default() -> Self {
Self {
info: None,
events: StatefulList::new(),
txs: StatefulList::new(),
deployment: None,
calls: StatefulList::new(),
call_blocks: HashMap::new(),
is_contract: false,
not_deployed: false,
visual_mode: false,
nav_items: Vec::new(),
nav_cursor: 0,
class_history: Vec::new(),
class_history_scroll: 0,
tab: AddressTab::Transactions,
context: None,
fetching_more_txs: false,
oldest_event_block: None,
sources_pending: HashSet::new(),
activity_probe: None,
dune_cursor_block: None,
rpc_cursor_block: None,
dune_has_more: false,
rpc_has_more: false,
ws_subscribed: false,
sanity_check_dispatched: false,
unfilled_gaps: Vec::new(),
gap_selected: None,
txs_render_state: ratatui::widgets::ListState::default(),
call_gaps: Vec::new(),
call_gap_selected: None,
calls_render_state: ratatui::widgets::ListState::default(),
scanned_call_ranges: Vec::new(),
call_tracked_from: None,
transfers: StatefulList::new(),
transfer_keys: HashMap::new(),
transfer_scanned_ranges: Vec::new(),
transfer_gaps: Vec::new(),
transfer_gap_selected: None,
transfers_render_state: ratatui::widgets::ListState::default(),
transfers_dispatched: false,
fetching_transfers: false,
transfer_color_map: AddressColorMap::new(),
transfer_counts: HashMap::new(),
transfer_color_processed_len: 0,
meta_txs: StatefulList::new(),
fetching_meta_txs: false,
meta_tx_cursor_block: None,
meta_tx_has_more: false,
meta_txs_dispatched: false,
meta_tx_from_block: 0,
meta_tx_last_window: crate::network::event_window::EXTEND_DOWN_INITIAL_WINDOW,
event_window: None,
call_sender_counts: HashMap::new(),
call_color_map: AddressColorMap::new(),
call_color_processed_len: 0,
tx_contract_counts: HashMap::new(),
tx_color_map: AddressColorMap::new(),
tx_color_processed_len: 0,
}
}
}
impl AddressInfoState {
pub fn clear(&mut self) {
self.info = None;
self.events = StatefulList::new();
self.class_history.clear();
self.class_history_scroll = 0;
self.visual_mode = false;
self.nav_items.clear();
self.nav_cursor = 0;
self.tab = AddressTab::Transactions;
self.txs = StatefulList::new();
self.deployment = None;
self.calls = StatefulList::new();
self.call_blocks.clear();
self.not_deployed = false;
self.fetching_more_txs = false;
self.oldest_event_block = None;
self.sources_pending.clear();
self.activity_probe = None;
self.dune_cursor_block = None;
self.rpc_cursor_block = None;
self.dune_has_more = false;
self.rpc_has_more = false;
self.ws_subscribed = false;
self.sanity_check_dispatched = false;
self.unfilled_gaps.clear();
self.gap_selected = None;
self.txs_render_state = ratatui::widgets::ListState::default();
self.call_gaps.clear();
self.call_gap_selected = None;
self.calls_render_state = ratatui::widgets::ListState::default();
self.scanned_call_ranges.clear();
self.call_tracked_from = None;
self.transfers = StatefulList::new();
self.transfer_keys.clear();
self.transfer_scanned_ranges.clear();
self.transfer_gaps.clear();
self.transfer_gap_selected = None;
self.transfers_render_state = ratatui::widgets::ListState::default();
self.transfers_dispatched = false;
self.fetching_transfers = false;
self.transfer_color_map = AddressColorMap::new();
self.transfer_counts.clear();
self.transfer_color_processed_len = 0;
self.meta_txs = StatefulList::new();
self.fetching_meta_txs = false;
self.meta_tx_cursor_block = None;
self.meta_tx_has_more = false;
self.meta_txs_dispatched = false;
self.meta_tx_from_block = 0;
self.meta_tx_last_window = crate::network::event_window::EXTEND_DOWN_INITIAL_WINDOW;
self.event_window = None;
self.call_sender_counts.clear();
self.call_color_map = AddressColorMap::new();
self.call_color_processed_len = 0;
self.tx_contract_counts.clear();
self.tx_color_map = AddressColorMap::new();
self.tx_color_processed_len = 0;
}
pub fn invalidate_call_color_cache(&mut self) {
self.call_sender_counts.clear();
self.call_color_map = AddressColorMap::new();
self.call_color_processed_len = 0;
}
pub fn invalidate_tx_color_cache(&mut self) {
self.tx_contract_counts.clear();
self.tx_color_map = AddressColorMap::new();
self.tx_color_processed_len = 0;
}
pub fn update_call_color_map(&mut self, is_known: impl Fn(&Felt) -> bool) {
if self.call_color_processed_len == self.calls.items.len() {
return;
}
self.call_sender_counts.clear();
for call in &self.calls.items {
let count = self.call_sender_counts.entry(call.sender).or_insert(0);
*count += 1;
if *count == 2 && !is_known(&call.sender) {
self.call_color_map.register(call.sender);
}
}
self.call_color_processed_len = self.calls.items.len();
}
pub fn update_tx_color_map(&mut self, is_known: impl Fn(&Felt) -> bool) {
if self.tx_color_processed_len == self.txs.items.len() {
return;
}
self.tx_contract_counts.clear();
for tx in &self.txs.items {
for contract in &tx.called_contracts {
let count = self.tx_contract_counts.entry(*contract).or_insert(0);
*count += 1;
if *count == 2 && !is_known(contract) {
self.tx_color_map.register(*contract);
}
}
}
self.tx_color_processed_len = self.txs.items.len();
}
pub fn has_more_data(&self) -> bool {
self.dune_has_more || self.rpc_has_more
}
pub fn pagination_cursor(&self) -> Option<u64> {
[
self.dune_cursor_block,
self.rpc_cursor_block,
self.oldest_event_block,
]
.into_iter()
.flatten()
.min()
}
pub fn build_nav_items(&mut self) {
let mut items: Vec<TxNavItem> = Vec::new();
if let Some(info) = &self.info
&& let Some(ch) = info.class_hash
{
items.push(TxNavItem::ClassHash(ch));
}
if let Some(deploy) = &self.deployment {
if deploy.hash != Felt::ZERO {
items.push(TxNavItem::Transaction(deploy.hash));
}
if deploy.block_number > 0 {
items.push(TxNavItem::Block(deploy.block_number));
}
if let Some(sender) = deploy.sender
&& let Some(info) = &self.info
&& sender != info.address
&& sender != Felt::ZERO
{
items.push(TxNavItem::Address(sender));
}
}
let header_len = items.len();
if self.tab == AddressTab::Transfers
&& let Some(row) = self.transfers.selected_item()
{
for item in [
TxNavItem::Transaction(row.tx_hash),
TxNavItem::Block(row.block_number),
TxNavItem::Address(row.from),
TxNavItem::Address(row.to),
TxNavItem::Address(row.token),
] {
let skip = match &item {
TxNavItem::Address(a) => Some(*a) == self.context || *a == Felt::ZERO,
TxNavItem::Block(b) => *b == 0,
_ => false,
};
if !skip && !items.contains(&item) {
items.push(item);
}
}
}
self.nav_cursor = if items.len() > header_len {
header_len
} else {
0
};
self.nav_items = items;
}
pub fn nav_step(&mut self, delta: i64) {
if self.nav_items.is_empty() {
return;
}
let len = self.nav_items.len() as i64;
let next = (self.nav_cursor as i64 + delta).rem_euclid(len) as usize;
self.nav_cursor = next;
}
pub fn filter_deployment_txs(
&mut self,
address: Felt,
txs: Vec<AddressTxSummary>,
) -> Vec<AddressTxSummary> {
let mut regular = Vec::with_capacity(txs.len());
for tx in txs {
let self_deploy =
tx.tx_type == "DEPLOY_ACCOUNT" && tx.sender.is_none_or(|s| s == address);
let foreign_deploy =
tx.tx_type.starts_with("DEPLOY") || tx.sender.is_some_and(|s| s != address);
if self_deploy || foreign_deploy {
let should_set = self.deployment.is_none()
|| self
.deployment
.as_ref()
.is_some_and(|d| d.hash == Felt::ZERO);
if should_set {
self.deployment = Some(tx.clone());
}
if self_deploy {
regular.push(tx);
}
} else {
regular.push(tx);
}
}
regular
}
pub fn merge_tx_summaries(&mut self, incoming: Vec<AddressTxSummary>) {
if incoming.is_empty() {
return;
}
let mut seen_hashes: HashSet<Felt> = self.txs.items.iter().map(|t| t.hash).collect();
let had_selection = self.txs.state.selected();
let mut called_contracts_upgraded = false;
for item in incoming {
if seen_hashes.contains(&item.hash) {
if let Some(existing) = self.txs.items.iter_mut().find(|t| t.hash == item.hash) {
called_contracts_upgraded |= upgrade_tx_summary(existing, &item);
}
} else {
seen_hashes.insert(item.hash);
self.txs.items.push(item);
}
}
if called_contracts_upgraded {
self.invalidate_tx_color_cache();
}
self.txs.items.sort_by(|a, b| b.nonce.cmp(&a.nonce));
if let Some(sel) = had_selection {
if sel < self.txs.items.len() {
self.txs.state.select(Some(sel));
}
} else if !self.txs.items.is_empty() {
self.txs.select_first();
}
if let Some(oldest) = self
.txs
.items
.iter()
.filter(|t| t.block_number > 0)
.map(|t| t.block_number)
.min()
{
self.oldest_event_block = Some(oldest);
}
}
pub fn merge_calls(&mut self, incoming: Vec<ContractCallSummary>) {
if incoming.is_empty() {
return;
}
let mut merged = std::mem::take(&mut self.calls.items);
merged.extend(incoming);
self.calls.items = crate::data::types::deduplicate_contract_calls(merged);
self.calls
.items
.sort_by(|a, b| b.block_number.cmp(&a.block_number));
self.call_blocks = self
.calls
.items
.iter()
.map(|c| (c.tx_hash, c.block_number))
.collect();
}
pub fn insert_call(&mut self, call: ContractCallSummary) -> bool {
if self.call_blocks.contains_key(&call.tx_hash) {
return false;
}
let idx = self
.calls
.items
.partition_point(|c| c.block_number >= call.block_number);
self.call_blocks.insert(call.tx_hash, call.block_number);
self.calls.items.insert(idx, call);
true
}
pub fn call_position(&self, tx_hash: Felt) -> Option<usize> {
let block = *self.call_blocks.get(&tx_hash)?;
let start = Self::first_index_with_key(&self.calls.items, |c| c.block_number, block)?;
self.calls.items[start..]
.iter()
.take_while(|c| c.block_number == block)
.position(|c| c.tx_hash == tx_hash)
.map(|i| start + i)
}
pub fn find_call_mut(&mut self, tx_hash: Felt) -> Option<&mut ContractCallSummary> {
let i = self.call_position(tx_hash)?;
Some(&mut self.calls.items[i])
}
pub fn calls_by_hash<'a>(
&self,
hashes: impl IntoIterator<Item = &'a Felt>,
) -> Vec<ContractCallSummary> {
hashes
.into_iter()
.filter_map(|h| self.call_position(*h))
.map(|i| self.calls.items[i].clone())
.collect()
}
fn first_index_with_key<T>(items: &[T], key: impl Fn(&T) -> u64, target: u64) -> Option<usize> {
let p = items.partition_point(|x| key(x) > target);
(p < items.len() && key(&items[p]) == target).then_some(p)
}
pub fn detect_unfilled_gaps(&self) -> Vec<UnfilledGap> {
if self.is_contract {
return Vec::new();
}
let mut pairs: Vec<(u64, u64)> = self
.txs
.items
.iter()
.filter(|t| t.block_number > 0)
.map(|t| (t.nonce, t.block_number))
.collect();
if pairs.len() < 2 {
return Vec::new();
}
pairs.sort_by_key(|(n, _)| *n);
let mut out = Vec::new();
for w in pairs.windows(2) {
let (lo_nonce, lo_block) = w[0];
let (hi_nonce, hi_block) = w[1];
let missing = hi_nonce.saturating_sub(lo_nonce).saturating_sub(1);
if missing == 0 {
continue;
}
let span = hi_block.saturating_sub(lo_block);
if span <= SMALL_GAP_SPAN_BLOCKS {
continue;
}
out.push(UnfilledGap {
lo_nonce,
hi_nonce,
lo_block,
hi_block,
missing_count: missing,
fill_dispatched: false,
});
}
out
}
pub fn refresh_unfilled_gaps(&mut self) {
let prev_inflight: std::collections::HashMap<u64, u64> = self
.unfilled_gaps
.iter()
.filter(|g| g.fill_dispatched)
.map(|g| (g.lo_nonce, g.hi_nonce))
.collect();
let mut next = self.detect_unfilled_gaps();
for g in next.iter_mut() {
if let Some(prev_hi) = prev_inflight.get(&g.lo_nonce)
&& *prev_hi == g.hi_nonce
{
g.fill_dispatched = true;
}
}
self.unfilled_gaps = next;
if let Some(sel) = self.gap_selected
&& !self.unfilled_gaps.iter().any(|g| g.lo_nonce == sel)
{
self.gap_selected = None;
}
}
pub fn gap_render_positions(&self) -> Vec<(usize, u64)> {
let mut out: Vec<(usize, u64)> = self
.unfilled_gaps
.iter()
.filter_map(|g| {
Self::first_index_with_key(&self.txs.items, |t| t.nonce, g.lo_nonce)
.map(|p| (p, g.lo_nonce))
})
.collect();
out.sort_by_key(|(p, _)| *p);
out
}
fn rendered_len(&self, gaps: &[(usize, u64)]) -> usize {
self.txs.items.len() + gaps.len()
}
fn tx_pos_to_rendered(tx_pos: usize, gaps: &[(usize, u64)]) -> usize {
tx_pos + gaps.iter().filter(|(p, _)| *p <= tx_pos).count()
}
fn gap_rendered_idx(gaps: &[(usize, u64)], idx_in_gaps: usize) -> usize {
gaps[idx_in_gaps].0 + idx_in_gaps
}
pub fn tx_list_rendered_selected(&self) -> Option<usize> {
self.tx_list_rendered_selected_with(&self.gap_render_positions())
}
pub fn tx_list_rendered_selected_with(&self, gaps: &[(usize, u64)]) -> Option<usize> {
if let Some(sel_lo) = self.gap_selected
&& let Some(g_idx) = gaps.iter().position(|(_, lo)| *lo == sel_lo)
{
return Some(Self::gap_rendered_idx(gaps, g_idx));
}
let tx_idx = self.txs.state.selected()?;
Some(Self::tx_pos_to_rendered(tx_idx, gaps))
}
pub fn selected_gap(&self) -> Option<&UnfilledGap> {
let lo = self.gap_selected?;
self.unfilled_gaps.iter().find(|g| g.lo_nonce == lo)
}
fn current_rendered(&self, gaps: &[(usize, u64)]) -> usize {
if let Some(sel_lo) = self.gap_selected
&& let Some(g_idx) = gaps.iter().position(|(_, lo)| *lo == sel_lo)
{
return Self::gap_rendered_idx(gaps, g_idx);
}
let t = self.txs.state.selected().unwrap_or(0);
Self::tx_pos_to_rendered(t, gaps)
}
fn first_gap_crossed(gaps: &[(usize, u64)], cur: usize, target: usize) -> Option<usize> {
if cur == target {
return None;
}
if target > cur {
gaps.iter().enumerate().find_map(|(g_idx, (p, _))| {
let r = p + g_idx;
(r > cur && r <= target).then_some(r)
})
} else {
gaps.iter().enumerate().rev().find_map(|(g_idx, (p, _))| {
let r = p + g_idx;
(r < cur && r >= target).then_some(r)
})
}
}
fn apply_rendered(&mut self, r: usize, gaps: &[(usize, u64)]) {
match rendered_row(r, gaps) {
RenderedRow::Gap(lo) => self.gap_selected = Some(lo),
RenderedRow::Item(t) => {
self.gap_selected = None;
self.txs.state.select(Some(t));
}
}
}
fn tx_list_step(&mut self, delta: i64) {
if self.txs.items.is_empty() || delta == 0 {
return;
}
let gaps = self.gap_render_positions();
let rendered_max = self.rendered_len(&gaps).saturating_sub(1);
let cur = self.current_rendered(&gaps);
let target = ((cur as i64) + delta).clamp(0, rendered_max as i64) as usize;
let final_r = Self::first_gap_crossed(&gaps, cur, target).unwrap_or(target);
self.apply_rendered(final_r, &gaps);
}
pub fn tx_list_next(&mut self) {
self.tx_list_step(1);
}
pub fn tx_list_previous(&mut self) {
self.tx_list_step(-1);
}
pub fn tx_list_select_first(&mut self) {
if self.txs.items.is_empty() {
return;
}
let gaps = self.gap_render_positions();
let cur = self.current_rendered(&gaps);
let final_r = Self::first_gap_crossed(&gaps, cur, 0).unwrap_or(0);
self.apply_rendered(final_r, &gaps);
}
pub fn tx_list_select_last(&mut self) {
if self.txs.items.is_empty() {
return;
}
let gaps = self.gap_render_positions();
let rendered_max = self.rendered_len(&gaps).saturating_sub(1);
let cur = self.current_rendered(&gaps);
let final_r = Self::first_gap_crossed(&gaps, cur, rendered_max).unwrap_or(rendered_max);
self.apply_rendered(final_r, &gaps);
}
pub fn tx_list_scroll_by(&mut self, delta: i64) {
self.tx_list_step(delta);
}
pub fn detect_unfilled_call_gaps(&self) -> Vec<UnfilledCallGap> {
let gap = |lo_block, hi_block| UnfilledCallGap {
lo_block,
hi_block,
fill_dispatched: false,
};
let tracked_from = self.call_tracked_from.unwrap_or(u64::MAX);
let mut out = Vec::new();
let mut prev: Option<u64> = None;
for b in self.calls.items.iter().rev().map(|c| c.block_number) {
if b == 0 || prev == Some(b) {
continue;
}
if let Some(lo_block) = prev
&& b <= tracked_from
&& b - lo_block > CALL_GAP_SPAN_BLOCKS
&& !self
.scanned_call_ranges
.iter()
.any(|(rlo, rhi)| *rlo <= lo_block && b <= *rhi)
{
out.push(gap(lo_block, b));
}
prev = Some(b);
}
if let Some(t) = self.call_tracked_from {
let mut cursor = t;
for &(rlo, rhi) in &self.scanned_call_ranges {
if rhi < cursor {
continue;
}
if rlo > cursor {
out.push(gap(cursor.saturating_sub(1), rlo));
}
cursor = cursor.max(rhi.saturating_add(1));
}
}
out.sort_by_key(|g| g.lo_block);
out
}
pub fn note_call_tracked_from(&mut self, from: u64) {
self.call_tracked_from = Some(self.call_tracked_from.map_or(from, |t| t.min(from)));
}
pub fn note_scanned_call_range(&mut self, lo: u64, hi: u64) {
crate::utils::merge_block_interval(&mut self.scanned_call_ranges, lo, hi);
}
pub fn refresh_unfilled_call_gaps(&mut self) {
let prev_inflight: HashMap<u64, u64> = self
.call_gaps
.iter()
.filter(|g| g.fill_dispatched)
.map(|g| (g.lo_block, g.hi_block))
.collect();
let mut next = self.detect_unfilled_call_gaps();
for g in next.iter_mut() {
if let Some(prev_hi) = prev_inflight.get(&g.lo_block)
&& *prev_hi == g.hi_block
{
g.fill_dispatched = true;
}
}
self.call_gaps = next;
if let Some(sel) = self.call_gap_selected
&& !self.call_gaps.iter().any(|g| g.lo_block == sel)
{
self.call_gap_selected = None;
}
}
pub fn call_gap_render_positions(&self) -> Vec<(usize, u64)> {
let mut out: Vec<(usize, u64)> = self
.call_gaps
.iter()
.map(|g| {
let p = self
.calls
.items
.partition_point(|c| c.block_number >= g.hi_block);
(p, g.lo_block)
})
.collect();
out.sort_by_key(|(p, lo)| (*p, std::cmp::Reverse(*lo)));
out
}
pub fn selected_call_gap(&self) -> Option<&UnfilledCallGap> {
let lo = self.call_gap_selected?;
self.call_gaps.iter().find(|g| g.lo_block == lo)
}
fn call_rendered_len(&self, gaps: &[(usize, u64)]) -> usize {
self.calls.items.len() + gaps.len()
}
fn call_current_rendered(&self, gaps: &[(usize, u64)]) -> usize {
if let Some(sel_lo) = self.call_gap_selected
&& let Some(g_idx) = gaps.iter().position(|(_, lo)| *lo == sel_lo)
{
return Self::gap_rendered_idx(gaps, g_idx);
}
let c = self.calls.state.selected().unwrap_or(0);
Self::tx_pos_to_rendered(c, gaps)
}
fn apply_call_rendered(&mut self, r: usize, gaps: &[(usize, u64)]) {
match rendered_row(r, gaps) {
RenderedRow::Gap(lo) => self.call_gap_selected = Some(lo),
RenderedRow::Item(c) => {
self.call_gap_selected = None;
self.calls.state.select(Some(c));
}
}
}
fn call_list_step(&mut self, delta: i64) {
if self.calls.items.is_empty() || delta == 0 {
return;
}
let gaps = self.call_gap_render_positions();
let rendered_max = self.call_rendered_len(&gaps).saturating_sub(1);
let cur = self.call_current_rendered(&gaps);
let target = ((cur as i64) + delta).clamp(0, rendered_max as i64) as usize;
let final_r = Self::first_gap_crossed(&gaps, cur, target).unwrap_or(target);
self.apply_call_rendered(final_r, &gaps);
}
pub fn call_list_next(&mut self) {
self.call_list_step(1);
}
pub fn call_list_previous(&mut self) {
self.call_list_step(-1);
}
pub fn call_list_scroll_by(&mut self, delta: i64) {
self.call_list_step(delta);
}
pub fn call_list_select_first(&mut self) {
if self.calls.items.is_empty() {
return;
}
let gaps = self.call_gap_render_positions();
let cur = self.call_current_rendered(&gaps);
let final_r = Self::first_gap_crossed(&gaps, cur, 0).unwrap_or(0);
self.apply_call_rendered(final_r, &gaps);
}
pub fn call_list_select_last(&mut self) {
if self.calls.items.is_empty() {
return;
}
let gaps = self.call_gap_render_positions();
let rendered_max = self.call_rendered_len(&gaps).saturating_sub(1);
let cur = self.call_current_rendered(&gaps);
let final_r = Self::first_gap_crossed(&gaps, cur, rendered_max).unwrap_or(rendered_max);
self.apply_call_rendered(final_r, &gaps);
}
pub fn call_list_rendered_selected(&self) -> Option<usize> {
self.call_list_rendered_selected_with(&self.call_gap_render_positions())
}
pub fn call_list_rendered_selected_with(&self, gaps: &[(usize, u64)]) -> Option<usize> {
if let Some(sel_lo) = self.call_gap_selected
&& let Some(g_idx) = gaps.iter().position(|(_, lo)| *lo == sel_lo)
{
return Some(Self::gap_rendered_idx(gaps, g_idx));
}
let c = self.calls.state.selected()?;
Some(Self::tx_pos_to_rendered(c, gaps))
}
}
impl AddressInfoState {
pub fn merge_transfers(&mut self, incoming: Vec<TokenTransfer>) -> usize {
let mut added = 0;
for t in incoming {
if self.transfer_keys.contains_key(&t.key()) {
if let Some(i) = self.transfer_position(&t)
&& upgrade_transfer(&mut self.transfers.items[i], &t)
{
let row = self.transfers.items.remove(i);
self.insert_transfer_sorted(row);
}
continue;
}
self.transfer_keys.insert(t.key(), t.block_number);
self.insert_transfer_sorted(t);
added += 1;
}
added
}
fn insert_transfer_sorted(&mut self, t: TokenTransfer) {
let idx = self.transfers.items.partition_point(|x| {
TokenTransfer::cmp_newest_first(x, &t) == std::cmp::Ordering::Less
});
self.transfers.items.insert(idx, t);
}
fn transfer_position(&self, t: &TokenTransfer) -> Option<usize> {
let block = *self.transfer_keys.get(&t.key())?;
let start = Self::first_index_with_key(&self.transfers.items, |r| r.block_number, block)?;
self.transfers.items[start..]
.iter()
.take_while(|r| r.block_number == block)
.position(|r| r.key() == t.key())
.map(|i| start + i)
}
pub fn note_transfer_scanned_range(&mut self, lo: u64, hi: u64) {
crate::utils::merge_block_interval(&mut self.transfer_scanned_ranges, lo, hi);
}
pub fn transfer_floor(&self) -> u64 {
self.deployment
.as_ref()
.map(|d| d.block_number)
.unwrap_or(0)
}
pub fn transfers_fully_scanned(&self) -> bool {
!self.transfer_scanned_ranges.is_empty() && self.transfer_gaps.is_empty()
}
pub fn refresh_transfer_gaps(&mut self) {
let inflight: HashMap<u64, u64> = self
.transfer_gaps
.iter()
.filter(|g| g.fill_dispatched)
.map(|g| (g.lo_block, g.hi_block))
.collect();
let mut next = scanned_range_gaps(&self.transfer_scanned_ranges, self.transfer_floor());
for g in next.iter_mut() {
g.fill_dispatched = inflight.get(&g.lo_block) == Some(&g.hi_block);
}
self.transfer_gaps = next;
if let Some(sel) = self.transfer_gap_selected
&& !self.transfer_gaps.iter().any(|g| g.lo_block == sel)
{
self.transfer_gap_selected = None;
}
}
pub fn ensure_transfer_selection(&mut self) {
if self.transfer_gap_selected.is_some() || self.transfers.state.selected().is_some() {
return;
}
if !self.transfers.items.is_empty() {
self.transfers.select_first();
} else if let Some((_, lo)) = self.transfer_gap_render_positions().first() {
self.transfer_gap_selected = Some(*lo);
}
}
pub fn transfer_gap_render_positions(&self) -> Vec<(usize, u64)> {
let mut out: Vec<(usize, u64)> = self
.transfer_gaps
.iter()
.map(|g| {
let p = self
.transfers
.items
.partition_point(|r| r.block_number > g.hi_block);
(p, g.lo_block)
})
.collect();
out.sort_by_key(|(p, lo)| (*p, std::cmp::Reverse(*lo)));
out
}
pub fn selected_transfer_gap(&self) -> Option<&TransferGap> {
let lo = self.transfer_gap_selected?;
self.transfer_gaps.iter().find(|g| g.lo_block == lo)
}
pub fn transfer_list_rendered_selected_with(&self, gaps: &[(usize, u64)]) -> Option<usize> {
if let Some(sel_lo) = self.transfer_gap_selected
&& let Some(g_idx) = gaps.iter().position(|(_, lo)| *lo == sel_lo)
{
return Some(Self::gap_rendered_idx(gaps, g_idx));
}
let i = self.transfers.state.selected()?;
Some(Self::tx_pos_to_rendered(i, gaps))
}
fn transfer_current_rendered(&self, gaps: &[(usize, u64)]) -> usize {
self.transfer_list_rendered_selected_with(gaps)
.unwrap_or_else(|| Self::tx_pos_to_rendered(0, gaps))
}
fn apply_transfer_rendered(&mut self, r: usize, gaps: &[(usize, u64)]) {
match rendered_row(r, gaps) {
RenderedRow::Gap(lo) => self.transfer_gap_selected = Some(lo),
RenderedRow::Item(i) => {
self.transfer_gap_selected = None;
self.transfers.state.select(Some(i));
}
}
}
fn transfer_list_step(&mut self, delta: i64) {
let gaps = self.transfer_gap_render_positions();
let len = self.transfers.items.len() + gaps.len();
if len == 0 || delta == 0 {
return;
}
let cur = self.transfer_current_rendered(&gaps);
let target = ((cur as i64) + delta).clamp(0, len as i64 - 1) as usize;
let final_r = Self::first_gap_crossed(&gaps, cur, target).unwrap_or(target);
self.apply_transfer_rendered(final_r, &gaps);
}
pub fn transfer_list_next(&mut self) {
self.transfer_list_step(1);
}
pub fn transfer_list_previous(&mut self) {
self.transfer_list_step(-1);
}
pub fn transfer_list_scroll_by(&mut self, delta: i64) {
self.transfer_list_step(delta);
}
pub fn transfer_list_select_first(&mut self) {
let gaps = self.transfer_gap_render_positions();
if self.transfers.items.len() + gaps.len() == 0 {
return;
}
let cur = self.transfer_current_rendered(&gaps);
let final_r = Self::first_gap_crossed(&gaps, cur, 0).unwrap_or(0);
self.apply_transfer_rendered(final_r, &gaps);
}
pub fn transfer_list_select_last(&mut self) {
let gaps = self.transfer_gap_render_positions();
let len = self.transfers.items.len() + gaps.len();
if len == 0 {
return;
}
let cur = self.transfer_current_rendered(&gaps);
let final_r = Self::first_gap_crossed(&gaps, cur, len - 1).unwrap_or(len - 1);
self.apply_transfer_rendered(final_r, &gaps);
}
pub fn update_transfer_color_map(&mut self, is_known: impl Fn(&Felt) -> bool) {
if self.transfer_color_processed_len == self.transfers.items.len() {
return;
}
let Some(viewed) = self.context else {
return;
};
self.transfer_color_map.set_sender(viewed);
self.transfer_counts.clear();
for t in &self.transfers.items {
for a in [t.from, t.to] {
if a == viewed {
continue;
}
let count = self.transfer_counts.entry(a).or_insert(0);
*count += 1;
if *count == 2 && !is_known(&a) {
self.transfer_color_map.register(a);
}
}
}
self.transfer_color_processed_len = self.transfers.items.len();
}
}
fn upgrade_transfer(existing: &mut TokenTransfer, incoming: &TokenTransfer) -> bool {
let mut reslot = false;
if existing.tx_index == 0 && incoming.tx_index != 0 {
existing.tx_index = incoming.tx_index;
reslot = true;
}
if existing.timestamp == 0 {
existing.timestamp = incoming.timestamp;
}
if existing.symbol.is_none() {
existing.symbol.clone_from(&incoming.symbol);
}
if existing.decimals.is_none() {
existing.decimals = incoming.decimals;
}
if existing.value_usd.is_none() {
existing.value_usd = incoming.value_usd;
}
reslot
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RenderedRow {
Gap(u64),
Item(usize),
}
pub fn rendered_row(r: usize, gaps: &[(usize, u64)]) -> RenderedRow {
let mut gaps_before = 0;
for (g_idx, (p, lo)) in gaps.iter().enumerate() {
match (p + g_idx).cmp(&r) {
std::cmp::Ordering::Equal => return RenderedRow::Gap(*lo),
std::cmp::Ordering::Less => gaps_before += 1,
std::cmp::Ordering::Greater => break,
}
}
RenderedRow::Item(r - gaps_before)
}
pub fn upgrade_tx_summary(existing: &mut AddressTxSummary, incoming: &AddressTxSummary) -> bool {
if existing.block_number == 0 && incoming.block_number > 0 {
existing.block_number = incoming.block_number;
}
if existing.status == "?" && incoming.status != "?" {
existing.status.clone_from(&incoming.status);
}
if existing.total_fee_fri == 0 && incoming.total_fee_fri > 0 {
existing.total_fee_fri = incoming.total_fee_fri;
}
if existing.timestamp == 0 && incoming.timestamp > 0 {
existing.timestamp = incoming.timestamp;
}
if existing.endpoint_names.is_empty() && !incoming.endpoint_names.is_empty() {
existing.endpoint_names.clone_from(&incoming.endpoint_names);
}
let called_contracts_filled =
existing.called_contracts.is_empty() && !incoming.called_contracts.is_empty();
if called_contracts_filled {
existing
.called_contracts
.clone_from(&incoming.called_contracts);
}
if existing.sender.is_none() && incoming.sender.is_some() {
existing.sender = incoming.sender;
}
if existing.tip == 0 && incoming.tip > 0 {
existing.tip = incoming.tip;
}
called_contracts_filled
}
#[cfg(test)]
mod tests {
use super::*;
use crate::data::types::AddressTxSummary;
use starknet::core::types::Felt;
fn transfer(block: u64, tx_index: u64, event_index: u64) -> TokenTransfer {
TokenTransfer {
token: Felt::from(7u64),
from: Felt::from(1u64),
to: Felt::from(2u64),
amount_low: 1,
amount_high: 0,
tx_hash: Felt::from(block * 1000 + tx_index),
block_number: block,
tx_index,
event_index,
timestamp: 0,
symbol: None,
decimals: None,
value_usd: None,
}
}
#[test]
fn scanned_range_gaps_cover_bottom_and_middle() {
assert!(scanned_range_gaps(&[], 0).is_empty());
let gaps = scanned_range_gaps(&[(100, 200), (301, 400)], 0);
assert_eq!(
gaps.iter()
.map(|g| (g.lo_block, g.hi_block))
.collect::<Vec<_>>(),
vec![(0, 99), (201, 300)]
);
let gaps = scanned_range_gaps(&[(100, 200)], 100);
assert!(gaps.is_empty());
let gaps = scanned_range_gaps(&[(100, 200)], 150);
assert!(gaps.is_empty());
assert!(scanned_range_gaps(&[(0, 10), (11, 20)], 0).is_empty());
}
#[test]
fn merge_transfers_dedups_sorts_and_upgrades() {
let mut st = AddressInfoState::default();
assert_eq!(
st.merge_transfers(vec![transfer(10, 0, 1), transfer(12, 3, 0)]),
2
);
let mut better = transfer(10, 0, 1);
better.tx_index = 5;
better.timestamp = 99;
assert_eq!(st.merge_transfers(vec![better]), 0);
assert_eq!(st.merge_transfers(vec![transfer(11, 0, 0)]), 1);
let blocks: Vec<u64> = st.transfers.items.iter().map(|t| t.block_number).collect();
assert_eq!(blocks, vec![12, 11, 10]);
let row = &st.transfers.items[2];
assert_eq!((row.tx_index, row.timestamp), (5, 99));
}
#[test]
fn transfer_gap_rows_render_between_and_below_rows() {
let mut st = AddressInfoState::default();
st.merge_transfers(vec![transfer(500, 0, 0), transfer(150, 0, 0)]);
st.note_transfer_scanned_range(100, 200);
st.note_transfer_scanned_range(400, 600);
st.refresh_transfer_gaps();
assert_eq!(st.transfer_gap_render_positions(), vec![(1, 201), (2, 0)]);
assert_eq!(st.transfer_gaps.len(), 2);
st.ensure_transfer_selection();
assert_eq!(st.transfers.state.selected(), Some(0));
st.transfer_list_next();
assert_eq!(st.transfer_gap_selected, Some(201));
st.transfer_list_next();
assert_eq!(st.transfers.state.selected(), Some(1));
assert_eq!(st.transfer_gap_selected, None);
st.transfer_list_select_last();
assert_eq!(st.transfer_gap_selected, Some(0));
st.transfer_gap_selected = Some(201);
st.note_transfer_scanned_range(201, 399);
st.refresh_transfer_gaps();
assert_eq!(st.transfer_gaps.len(), 1);
assert_eq!(st.transfer_gap_selected, None);
}
#[test]
fn lone_gap_row_is_selectable_without_rows() {
let mut st = AddressInfoState::default();
st.note_transfer_scanned_range(900, 1000);
st.refresh_transfer_gaps();
st.ensure_transfer_selection();
assert_eq!(st.transfer_gap_selected, Some(0));
assert_eq!(
st.transfer_list_rendered_selected_with(&st.transfer_gap_render_positions()),
Some(0)
);
}
fn summary(nonce: u64, block: u64) -> AddressTxSummary {
AddressTxSummary {
hash: Felt::from(nonce + 1),
nonce,
block_number: block,
timestamp: 0,
endpoint_names: String::new(),
total_fee_fri: 0,
tip: 0,
tx_type: "INVOKE".into(),
status: "OK".into(),
sender: None,
called_contracts: Vec::new(),
}
}
fn state_with(txs: Vec<AddressTxSummary>) -> AddressInfoState {
let mut s = AddressInfoState::default();
s.txs.items = txs;
s
}
#[test]
fn no_gap_when_contiguous() {
let state = state_with(vec![summary(10, 100), summary(11, 102), summary(12, 104)]);
assert!(state.detect_unfilled_gaps().is_empty());
}
#[test]
fn no_gap_for_small_span() {
let state = state_with(vec![summary(10, 100), summary(16, 130)]);
assert!(state.detect_unfilled_gaps().is_empty());
}
#[test]
fn detects_wide_gap_even_with_few_missing() {
let state = state_with(vec![summary(10, 100), summary(13, 200)]);
let gaps = state.detect_unfilled_gaps();
assert_eq!(gaps.len(), 1);
let g = &gaps[0];
assert_eq!(g.lo_nonce, 10);
assert_eq!(g.hi_nonce, 13);
assert_eq!(g.missing_count, 2);
assert!(!g.fill_dispatched);
}
#[test]
fn detects_gap_by_block_span() {
let state = state_with(vec![summary(10, 100), summary(21, 2000)]);
let gaps = state.detect_unfilled_gaps();
assert_eq!(gaps.len(), 1);
assert_eq!(gaps[0].lo_nonce, 10);
assert_eq!(gaps[0].hi_nonce, 21);
assert_eq!(gaps[0].missing_count, 10);
}
#[test]
fn gap_threshold_boundary() {
let state = state_with(vec![
summary(10, 100),
summary(12, 100 + SMALL_GAP_SPAN_BLOCKS),
]);
assert!(state.detect_unfilled_gaps().is_empty());
let state = state_with(vec![
summary(10, 100),
summary(12, 100 + SMALL_GAP_SPAN_BLOCKS + 1),
]);
assert_eq!(state.detect_unfilled_gaps().len(), 1);
}
#[test]
fn contract_addresses_never_report_gap() {
let mut state = state_with(vec![summary(10, 100), summary(200, 500)]);
state.is_contract = true;
assert!(state.detect_unfilled_gaps().is_empty());
}
#[test]
fn reset_clears_unfilled_gaps() {
let mut state = state_with(vec![summary(10, 100), summary(21, 2000)]);
state.unfilled_gaps.push(UnfilledGap {
lo_nonce: 10,
hi_nonce: 21,
lo_block: 100,
hi_block: 2000,
missing_count: 10,
fill_dispatched: true,
});
state.sanity_check_dispatched = true;
state.clear();
assert!(state.unfilled_gaps.is_empty());
assert!(!state.sanity_check_dispatched);
}
#[test]
fn detects_every_qualifying_gap() {
let state = state_with(vec![
summary(10, 100),
summary(20, 1100), summary(22, 1110), summary(200, 5000), summary(201, 5001),
]);
let gaps = state.detect_unfilled_gaps();
assert_eq!(gaps.len(), 2);
let los: Vec<u64> = gaps.iter().map(|g| g.lo_nonce).collect();
assert_eq!(los, vec![10, 22]);
}
#[test]
fn refresh_preserves_dispatched_flag_when_gap_unchanged() {
let mut state = state_with(vec![summary(10, 100), summary(21, 2000)]);
state.unfilled_gaps = state.detect_unfilled_gaps();
state.unfilled_gaps[0].fill_dispatched = true;
state.refresh_unfilled_gaps();
assert_eq!(state.unfilled_gaps.len(), 1);
assert!(state.unfilled_gaps[0].fill_dispatched);
}
#[test]
fn refresh_clears_dispatched_flag_when_gap_shrinks() {
let mut state = state_with(vec![summary(10, 100), summary(21, 2000)]);
state.unfilled_gaps = state.detect_unfilled_gaps();
state.unfilled_gaps[0].fill_dispatched = true;
state.txs.items.push(summary(18, 1980));
state.txs.items.push(summary(19, 1990));
state.txs.items.push(summary(20, 1995));
state.refresh_unfilled_gaps();
assert_eq!(state.unfilled_gaps.len(), 1);
assert_eq!(state.unfilled_gaps[0].lo_nonce, 10);
assert_eq!(state.unfilled_gaps[0].hi_nonce, 18);
assert!(!state.unfilled_gaps[0].fill_dispatched);
}
#[test]
fn refresh_drops_stale_gap_selection() {
let mut state = state_with(vec![summary(10, 100), summary(21, 2000)]);
state.unfilled_gaps = state.detect_unfilled_gaps();
state.gap_selected = Some(10);
state.txs.items = (10..=21).map(|n| summary(n, 100 + n)).collect();
state.refresh_unfilled_gaps();
assert!(state.unfilled_gaps.is_empty());
assert!(state.gap_selected.is_none());
}
fn state_one_gap() -> AddressInfoState {
let mut state = state_with(vec![
summary(100, 5000),
summary(99, 4990),
summary(30, 200),
summary(29, 190),
]);
state.refresh_unfilled_gaps();
assert_eq!(state.unfilled_gaps.len(), 1);
state.txs.state.select(Some(0));
state
}
#[test]
fn next_lands_on_gap_when_crossing_forward() {
let mut state = state_one_gap();
state.txs.state.select(Some(1));
state.tx_list_next();
assert_eq!(state.gap_selected, Some(30));
assert_eq!(state.txs.state.selected(), Some(1));
}
#[test]
fn next_off_gap_lands_on_lo_nonce_tx_no_dispatch() {
let mut state = state_one_gap();
state.gap_selected = Some(30);
state.tx_list_next();
assert_eq!(state.gap_selected, None);
assert_eq!(state.txs.state.selected(), Some(2));
assert!(!state.unfilled_gaps[0].fill_dispatched);
}
#[test]
fn previous_lands_on_gap_when_crossing_backward() {
let mut state = state_one_gap();
state.txs.state.select(Some(2));
state.tx_list_previous();
assert_eq!(state.gap_selected, Some(30));
assert_eq!(state.txs.state.selected(), Some(2));
}
#[test]
fn previous_off_gap_lands_on_hi_nonce_tx() {
let mut state = state_one_gap();
state.gap_selected = Some(30);
state.tx_list_previous();
assert_eq!(state.gap_selected, None);
assert_eq!(state.txs.state.selected(), Some(1));
}
#[test]
fn scroll_by_clamps_on_gap_forward() {
let mut state = state_one_gap();
state.txs.state.select(Some(0));
state.tx_list_scroll_by(10);
assert_eq!(state.gap_selected, Some(30));
}
#[test]
fn scroll_by_clamps_on_gap_backward() {
let mut state = state_one_gap();
state.txs.state.select(Some(3));
state.tx_list_scroll_by(-10);
assert_eq!(state.gap_selected, Some(30));
}
#[test]
fn select_first_clamps_on_gap_from_below() {
let mut state = state_one_gap();
state.txs.state.select(Some(3));
state.tx_list_select_first();
assert_eq!(state.gap_selected, Some(30));
}
#[test]
fn select_last_clamps_on_gap_from_above() {
let mut state = state_one_gap();
state.txs.state.select(Some(0));
state.tx_list_select_last();
assert_eq!(state.gap_selected, Some(30));
}
#[test]
fn navigation_is_a_noop_with_no_gap() {
let mut state = state_with(vec![summary(10, 100), summary(11, 102)]);
state.refresh_unfilled_gaps();
assert!(state.unfilled_gaps.is_empty());
state.txs.state.select(Some(0));
state.tx_list_next();
assert_eq!(state.gap_selected, None);
assert_eq!(state.txs.state.selected(), Some(1));
}
fn state_two_gaps() -> AddressInfoState {
let mut state = state_with(vec![
summary(200, 9010),
summary(199, 9000),
summary(100, 5000),
summary(99, 4990),
summary(30, 200),
summary(29, 190),
]);
state.refresh_unfilled_gaps();
assert_eq!(state.unfilled_gaps.len(), 2);
state.txs.state.select(Some(0));
state
}
#[test]
fn scroll_by_clamps_on_first_of_multiple_gaps_forward() {
let mut state = state_two_gaps();
state.tx_list_scroll_by(20);
assert_eq!(state.gap_selected, Some(100));
}
#[test]
fn scroll_by_from_first_gap_clamps_on_second() {
let mut state = state_two_gaps();
state.gap_selected = Some(100);
state.tx_list_scroll_by(20);
assert_eq!(state.gap_selected, Some(30));
}
#[test]
fn step_walks_through_each_gap() {
let mut state = state_two_gaps();
state.txs.state.select(Some(1));
state.tx_list_next(); assert_eq!(state.gap_selected, Some(100));
state.tx_list_next(); assert_eq!(state.gap_selected, None);
assert_eq!(state.txs.state.selected(), Some(2));
state.tx_list_next(); assert_eq!(state.txs.state.selected(), Some(3));
state.tx_list_next(); assert_eq!(state.gap_selected, Some(30));
}
#[test]
fn rendered_selected_tracks_gap_and_tx_state() {
let mut state = state_two_gaps();
state.txs.state.select(Some(0));
assert_eq!(state.tx_list_rendered_selected(), Some(0));
state.txs.state.select(Some(3));
assert_eq!(state.tx_list_rendered_selected(), Some(4));
state.gap_selected = Some(100);
assert_eq!(state.tx_list_rendered_selected(), Some(2));
state.gap_selected = Some(30);
assert_eq!(state.tx_list_rendered_selected(), Some(5));
}
fn call_summary(sender: Felt, block: u64) -> ContractCallSummary {
ContractCallSummary {
tx_hash: Felt::from(block * 31 + 1),
sender,
function_name: String::new(),
block_number: block,
timestamp: 0,
total_fee_fri: 0,
status: "OK".into(),
nonce: None,
tip: 0,
inner_targets: Vec::new(),
}
}
fn call_at(block: u64) -> ContractCallSummary {
call_summary(Felt::from(0xC0FFEE_u64), block)
}
fn call_state_with(calls: Vec<ContractCallSummary>) -> AddressInfoState {
let mut s = AddressInfoState::default();
s.calls.items = calls;
s.calls
.items
.sort_by(|a, b| b.block_number.cmp(&a.block_number));
s
}
fn call_with_hash(hash: u64, block: u64) -> ContractCallSummary {
ContractCallSummary {
tx_hash: Felt::from(hash),
..call_at(block)
}
}
#[test]
fn insert_call_keeps_block_order_and_dedups() {
let mut s = AddressInfoState::default();
s.merge_calls(vec![call_at(100), call_at(300)]);
assert!(s.insert_call(call_with_hash(7, 200)));
assert!(s.insert_call(call_with_hash(8, 300)));
assert!(!s.insert_call(call_with_hash(7, 999)));
let blocks: Vec<u64> = s.calls.items.iter().map(|c| c.block_number).collect();
assert_eq!(blocks, vec![300, 300, 200, 100]);
assert_eq!(s.calls.items[1].tx_hash, Felt::from(8_u64));
assert_eq!(s.call_position(Felt::from(8_u64)), Some(1));
assert_eq!(s.call_position(Felt::from(7_u64)), Some(2));
assert_eq!(s.call_position(call_at(100).tx_hash), Some(3));
assert_eq!(s.call_position(Felt::from(9_u64)), None);
s.find_call_mut(Felt::from(7_u64)).unwrap().tip = 5;
let rows = s.calls_by_hash(&[Felt::from(7_u64), Felt::from(9_u64)]);
assert_eq!(rows.len(), 1);
assert_eq!(rows[0].tip, 5);
}
#[test]
fn call_gap_positions_pick_first_row_of_the_block() {
let mut s = AddressInfoState::default();
let top = 1_000 + 2 * CALL_GAP_SPAN_BLOCKS;
s.merge_calls(vec![call_at(1_000), call_with_hash(2, 1_000), call_at(top)]);
s.call_gaps = vec![
UnfilledCallGap {
lo_block: 42, hi_block: 43,
fill_dispatched: false,
},
UnfilledCallGap {
lo_block: 1_000,
hi_block: top,
fill_dispatched: false,
},
];
assert_eq!(s.call_gap_render_positions(), vec![(1, 1_000), (3, 42)]);
}
#[test]
fn tx_gap_positions_search_by_nonce() {
let mut s = AddressInfoState::default();
s.merge_tx_summaries(vec![
summary(10, 100),
summary(30, 3_000),
summary(21, 2_000),
]);
let gap = |lo: u64| UnfilledGap {
lo_nonce: lo,
hi_nonce: 21,
lo_block: 100,
hi_block: 2_000,
missing_count: 1,
fill_dispatched: false,
};
s.unfilled_gaps = vec![gap(10), gap(5)];
assert_eq!(s.gap_render_positions(), vec![(2, 10)]);
}
#[test]
#[ignore]
fn call_insert_and_lookup_timing() {
let n = 50_000u64;
let mut s = AddressInfoState::default();
s.merge_calls((0..n).map(|i| call_with_hash(i, i)).collect());
let mut old = s.calls.items.clone();
let t = std::time::Instant::now();
for i in 0..100u64 {
let c = call_with_hash(n + 10_000 + i, n - 1 - i * 37);
if !old.iter().any(|x| x.tx_hash == c.tx_hash) {
old.push(c);
old.sort_by_key(|x| std::cmp::Reverse(x.block_number));
}
}
let old_ins = t.elapsed() / 100;
let t = std::time::Instant::now();
for i in 0..1_000u64 {
assert!(s.insert_call(call_with_hash(n + i, n - 1 - i * 37)));
}
let ins = t.elapsed() / 1_000;
let t = std::time::Instant::now();
for i in 0..1_000u64 {
assert!(s.find_call_mut(Felt::from(n + i)).is_some());
}
let find = t.elapsed() / 1_000;
eprintln!(
"50k rows: push+sort {old_ins:?}/row → insert_call {ins:?}/row, find_call_mut {find:?}/row"
);
}
#[test]
fn no_call_gap_when_dense() {
let state = call_state_with(vec![call_at(1000), call_at(1010), call_at(1020)]);
assert!(state.detect_unfilled_call_gaps().is_empty());
}
#[test]
fn no_call_gap_for_zero_block_stubs() {
let state = call_state_with(vec![call_at(0), call_at(1_000_000)]);
assert!(state.detect_unfilled_call_gaps().is_empty());
}
#[test]
fn detects_call_gap_by_block_span() {
let state = call_state_with(vec![
call_at(1_200_500),
call_at(1_200_490),
call_at(1_005_000),
call_at(1_004_990),
]);
let gaps = state.detect_unfilled_call_gaps();
assert_eq!(gaps.len(), 1);
assert_eq!(gaps[0].lo_block, 1_005_000);
assert_eq!(gaps[0].hi_block, 1_200_490);
assert!(!gaps[0].fill_dispatched);
}
#[test]
fn call_gap_threshold_boundary() {
let state = call_state_with(vec![call_at(1000), call_at(1000 + CALL_GAP_SPAN_BLOCKS)]);
assert!(state.detect_unfilled_call_gaps().is_empty());
let state = call_state_with(vec![
call_at(1000),
call_at(1000 + CALL_GAP_SPAN_BLOCKS + 1),
]);
assert_eq!(state.detect_unfilled_call_gaps().len(), 1);
}
#[test]
fn tracked_region_flags_every_unscanned_range() {
let mut state = call_state_with(vec![call_at(1_500), call_at(1_800), call_at(2_600)]);
state.note_call_tracked_from(1_000);
state.note_scanned_call_range(1_000, 2_000);
state.note_scanned_call_range(2_500, 3_000);
let gaps = state.detect_unfilled_call_gaps();
assert_eq!(gaps.len(), 1);
assert_eq!((gaps[0].lo_block, gaps[0].hi_block), (2_000, 2_500));
state.call_gaps = gaps;
assert_eq!(state.call_gap_render_positions(), vec![(1, 2_000)]);
state.note_scanned_call_range(2_000, 2_500);
assert!(state.detect_unfilled_call_gaps().is_empty());
}
#[test]
fn tracked_region_floor_and_older_rows() {
let mut state = call_state_with(vec![call_at(100), call_at(900), call_at(2_000)]);
state.note_call_tracked_from(1_000);
state.note_scanned_call_range(1_500, 3_000);
let gaps = state.detect_unfilled_call_gaps();
assert_eq!(
gaps.len(),
1,
"only the unscanned bottom of the tracked region"
);
assert_eq!((gaps[0].lo_block, gaps[0].hi_block), (999, 1_500));
state.note_call_tracked_from(5_000);
assert_eq!(state.call_tracked_from, Some(1_000));
}
#[test]
fn refresh_preserves_call_gap_dispatched_when_unchanged() {
let mut state = call_state_with(vec![call_at(1_005_000), call_at(1_200_490)]);
state.call_gaps = state.detect_unfilled_call_gaps();
state.call_gaps[0].fill_dispatched = true;
state.refresh_unfilled_call_gaps();
assert_eq!(state.call_gaps.len(), 1);
assert!(state.call_gaps[0].fill_dispatched);
}
#[test]
fn refresh_clears_call_gap_dispatched_when_gap_shrinks() {
let mut state = call_state_with(vec![call_at(1_005_000), call_at(1_200_490)]);
state.call_gaps = state.detect_unfilled_call_gaps();
state.call_gaps[0].fill_dispatched = true;
state.calls.items.push(call_at(1_200_000));
state
.calls
.items
.sort_by(|a, b| b.block_number.cmp(&a.block_number));
state.refresh_unfilled_call_gaps();
assert_eq!(state.call_gaps.len(), 1);
assert_eq!(state.call_gaps[0].lo_block, 1_005_000);
assert_eq!(state.call_gaps[0].hi_block, 1_200_000);
assert!(!state.call_gaps[0].fill_dispatched);
}
#[test]
fn refresh_drops_stale_call_gap_selection() {
let mut state = call_state_with(vec![call_at(1_005_000), call_at(1_200_490)]);
state.refresh_unfilled_call_gaps();
state.call_gap_selected = Some(1_005_000);
state.calls.items = (0..=20)
.map(|i| call_at(1_005_000 + i * (CALL_GAP_SPAN_BLOCKS / 2)))
.collect();
state
.calls
.items
.sort_by(|a, b| b.block_number.cmp(&a.block_number));
state.refresh_unfilled_call_gaps();
assert!(state.call_gaps.is_empty());
assert!(state.call_gap_selected.is_none());
}
#[test]
fn scanned_range_suppresses_call_gap() {
let mut state = call_state_with(vec![call_at(1_005_000), call_at(1_200_490)]);
assert_eq!(state.detect_unfilled_call_gaps().len(), 1);
state.note_scanned_call_range(1_005_000, 1_200_490);
assert!(state.detect_unfilled_call_gaps().is_empty());
}
#[test]
fn note_scanned_call_range_merges_overlaps() {
let mut state = AddressInfoState::default();
state.note_scanned_call_range(100, 200);
state.note_scanned_call_range(150, 300); state.note_scanned_call_range(301, 400); state.note_scanned_call_range(1000, 1100); assert_eq!(state.scanned_call_ranges, vec![(100, 400), (1000, 1100)]);
}
fn call_state_one_gap() -> AddressInfoState {
let mut state = call_state_with(vec![
call_at(200_000),
call_at(199_000),
call_at(200),
call_at(190),
]);
state.refresh_unfilled_call_gaps();
assert_eq!(state.call_gaps.len(), 1);
assert_eq!(state.call_gaps[0].lo_block, 200);
state.calls.state.select(Some(0));
state
}
#[test]
fn call_next_lands_on_gap_when_crossing_forward() {
let mut state = call_state_one_gap();
state.calls.state.select(Some(1));
state.call_list_next();
assert_eq!(state.call_gap_selected, Some(200));
assert_eq!(state.calls.state.selected(), Some(1));
}
#[test]
fn call_next_off_gap_lands_on_lo_block_call() {
let mut state = call_state_one_gap();
state.call_gap_selected = Some(200);
state.call_list_next();
assert_eq!(state.call_gap_selected, None);
assert_eq!(state.calls.state.selected(), Some(2));
}
#[test]
fn call_scroll_by_clamps_on_gap_forward() {
let mut state = call_state_one_gap();
state.calls.state.select(Some(0));
state.call_list_scroll_by(10);
assert_eq!(state.call_gap_selected, Some(200));
}
#[test]
fn call_rendered_selected_tracks_gap_and_call_state() {
let mut state = call_state_one_gap();
state.calls.state.select(Some(0));
assert_eq!(state.call_list_rendered_selected(), Some(0));
state.calls.state.select(Some(2));
assert_eq!(state.call_list_rendered_selected(), Some(3));
state.call_gap_selected = Some(200);
assert_eq!(state.call_list_rendered_selected(), Some(2));
}
#[test]
fn call_nav_is_noop_with_no_gap() {
let mut state = call_state_with(vec![call_at(1000), call_at(1010)]);
state.refresh_unfilled_call_gaps();
assert!(state.call_gaps.is_empty());
state.calls.state.select(Some(0));
state.call_list_next();
assert_eq!(state.call_gap_selected, None);
assert_eq!(state.calls.state.selected(), Some(1));
}
fn build_call_corpus(n: usize) -> Vec<ContractCallSummary> {
const POOL_SIZE: usize = 50;
let hot_pool: Vec<Felt> = (0..POOL_SIZE)
.map(|i| Felt::from(0x1000_u64 + i as u64))
.collect();
let mut hot_cursor: usize = 0;
(0..n)
.map(|i| {
let sender = if i % 10 < 3 {
Felt::from(0x9000_0000_u64 + i as u64)
} else {
let s = hot_pool[hot_cursor % POOL_SIZE];
hot_cursor = hot_cursor.wrapping_add(7);
s
};
call_summary(sender, (n - i) as u64)
})
.collect()
}
#[test]
#[ignore = "release-mode microbenchmark; run with `cargo test --release bench_update_call_color_map -- --ignored --nocapture`"]
fn bench_update_call_color_map() {
let sizes = [1_000usize, 5_000, 10_000, 25_000];
for &n in &sizes {
let corpus = build_call_corpus(n);
let mut state = AddressInfoState::default();
state.calls.items = corpus.clone();
let t0 = std::time::Instant::now();
state.update_call_color_map(|_| false);
let cold = t0.elapsed();
let t1 = std::time::Instant::now();
for _ in 0..1_000 {
state.update_call_color_map(|_| false);
}
let warm_avg = t1.elapsed() / 1_000;
let registered = state.call_color_map.slots_count();
assert!(
registered >= 50,
"expected ≥50 registered (hot pool), got {} at n={}",
registered,
n
);
println!(
"n={:>5} cold_rebuild={:>8.3?} warm_per_call={:>8.3?} registered={}",
n, cold, warm_avg, registered
);
assert!(
cold < std::time::Duration::from_millis(100),
"cold rebuild for n={} took {:?}, exceeds 100 ms budget",
n,
cold
);
}
}
}
#[cfg(test)]
mod rendered_row_tests {
use super::*;
#[test]
fn no_gaps_is_identity() {
assert_eq!(rendered_row(7, &[]), RenderedRow::Item(7));
}
#[test]
fn gap_rows_and_items_interleave() {
let gaps = [(0, 100), (5, 200)];
assert_eq!(rendered_row(0, &gaps), RenderedRow::Gap(100));
assert_eq!(rendered_row(1, &gaps), RenderedRow::Item(0));
assert_eq!(rendered_row(5, &gaps), RenderedRow::Item(4));
assert_eq!(rendered_row(6, &gaps), RenderedRow::Gap(200));
assert_eq!(rendered_row(7, &gaps), RenderedRow::Item(5));
assert_eq!(rendered_row(9, &gaps), RenderedRow::Item(7));
}
#[test]
fn round_trips_with_tx_pos_to_rendered() {
let gaps = [(2, 10), (2, 11), (9, 12)];
for pos in 0..20 {
let r = AddressInfoState::tx_pos_to_rendered(pos, &gaps);
assert_eq!(rendered_row(r, &gaps), RenderedRow::Item(pos));
}
}
}