use std::collections::{HashMap, HashSet};
use std::future::Future;
use std::path::Path;
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use async_trait::async_trait;
use futures::FutureExt;
use futures::future::Shared;
use r2d2::Pool;
use r2d2_sqlite::SqliteConnectionManager;
use rusqlite::{TransactionBehavior, params};
use starknet::core::types::{ContractClass, Felt, TransactionTrace};
use tracing::{debug, info, trace, warn};
type DbPool = Pool<SqliteConnectionManager>;
#[allow(unused_imports)]
use super::types::*;
use super::{DataSource, FilterKind};
use crate::error::{Result, StarktopError};
fn is_final_status(status: &str) -> bool {
status == "ACCEPTED_ON_L1"
}
type SharedTxFut =
Shared<Pin<Box<dyn Future<Output = std::result::Result<SnTransaction, String>> + Send>>>;
type SharedRxFut =
Shared<Pin<Box<dyn Future<Output = std::result::Result<SnReceipt, String>> + Send>>>;
type SharedTraceFut =
Shared<Pin<Box<dyn Future<Output = std::result::Result<TransactionTrace, String>> + Send>>>;
pub struct CachingDataSource {
upstream: Arc<dyn DataSource>,
db: DbPool,
pending_txs: Mutex<HashMap<Felt, SharedTxFut>>,
pending_receipts: Mutex<HashMap<Felt, SharedRxFut>>,
pending_traces: Mutex<HashMap<Felt, SharedTraceFut>>,
head: Option<Arc<dyn crate::data::LatestBlockSource>>,
}
impl CachingDataSource {
pub fn new(upstream: Arc<dyn DataSource>, cache_path: &Path) -> Result<Self> {
let manager = SqliteConnectionManager::file(cache_path).with_init(|c| {
c.execute_batch(
"PRAGMA journal_mode = WAL; \
PRAGMA synchronous = NORMAL; \
PRAGMA temp_store = MEMORY; \
PRAGMA busy_timeout = 5000;",
)
});
let pool = Pool::builder()
.max_size(8)
.build(manager)
.map_err(|e| StarktopError::Config(format!("Failed to build cache db pool: {e}")))?;
let db = pool
.get()
.map_err(|e| StarktopError::Config(format!("Failed to open cache db: {e}")))?;
db.execute_batch(
"
CREATE TABLE IF NOT EXISTS blocks (
number INTEGER PRIMARY KEY,
data TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS transactions (
hash TEXT PRIMARY KEY,
block_number INTEGER,
data TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS receipts (
tx_hash TEXT PRIMARY KEY,
data TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS tx_traces (
tx_hash TEXT PRIMARY KEY,
data TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS block_transactions (
block_number INTEGER,
tx_index INTEGER,
tx_hash TEXT NOT NULL,
data TEXT NOT NULL,
PRIMARY KEY (block_number, tx_index)
);
CREATE TABLE IF NOT EXISTS parsed_abis (
class_hash TEXT PRIMARY KEY,
data TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS address_events (
address TEXT NOT NULL,
block_number INTEGER NOT NULL,
tx_hash TEXT NOT NULL,
event_index INTEGER NOT NULL,
data TEXT NOT NULL,
PRIMARY KEY (address, block_number, tx_hash, event_index)
);
CREATE TABLE IF NOT EXISTS address_txs (
address TEXT NOT NULL,
tx_index INTEGER NOT NULL,
data TEXT NOT NULL,
PRIMARY KEY (address, tx_index)
);
CREATE INDEX IF NOT EXISTS idx_addr_txs ON address_txs(address);
CREATE INDEX IF NOT EXISTS idx_tx_block ON transactions(block_number);
CREATE INDEX IF NOT EXISTS idx_block_tx ON block_transactions(block_number);
CREATE TABLE IF NOT EXISTS address_calls (
address TEXT NOT NULL,
tx_hash TEXT NOT NULL,
block_number INTEGER NOT NULL,
data TEXT NOT NULL,
PRIMARY KEY (address, tx_hash)
);
CREATE TABLE IF NOT EXISTS address_call_scanned_ranges (
address TEXT NOT NULL,
lo_block INTEGER NOT NULL,
hi_block INTEGER NOT NULL,
PRIMARY KEY (address, lo_block)
);
CREATE INDEX IF NOT EXISTS idx_addr_call_scanned
ON address_call_scanned_ranges(address);
CREATE TABLE IF NOT EXISTS address_transfers (
address TEXT NOT NULL,
tx_hash TEXT NOT NULL,
event_index INTEGER NOT NULL,
block_number INTEGER NOT NULL,
data TEXT NOT NULL,
PRIMARY KEY (address, tx_hash, event_index)
);
CREATE INDEX IF NOT EXISTS idx_addr_transfers
ON address_transfers(address, block_number);
CREATE TABLE IF NOT EXISTS address_transfer_scanned_ranges (
address TEXT NOT NULL,
lo_block INTEGER NOT NULL,
hi_block INTEGER NOT NULL,
PRIMARY KEY (address, lo_block)
);
CREATE TABLE IF NOT EXISTS address_activity (
address TEXT PRIMARY KEY,
min_block INTEGER NOT NULL,
max_block INTEGER NOT NULL,
event_count INTEGER NOT NULL DEFAULT 0,
updated_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS class_hashes (
address TEXT PRIMARY KEY,
class_hash TEXT NOT NULL,
fetched_at_block INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS block_hash_index (
hash TEXT PRIMARY KEY,
number INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS deploy_info (
address TEXT PRIMARY KEY,
deploy_tx_hash TEXT NOT NULL,
deploy_block INTEGER NOT NULL,
deployer TEXT
);
CREATE TABLE IF NOT EXISTS class_history (
address TEXT NOT NULL,
block_number INTEGER NOT NULL,
class_hash TEXT NOT NULL,
PRIMARY KEY (address, block_number)
);
CREATE INDEX IF NOT EXISTS idx_class_history_addr
ON class_history(address, block_number DESC);
CREATE TABLE IF NOT EXISTS class_history_meta (
address TEXT PRIMARY KEY,
last_known_block INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS cached_nonces (
address TEXT PRIMARY KEY,
nonce TEXT NOT NULL,
block_number INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS address_search_progress (
address TEXT NOT NULL,
filter_kind TEXT NOT NULL DEFAULT 'unkeyed',
max_searched_block INTEGER NOT NULL,
min_searched_block INTEGER NOT NULL DEFAULT 0,
PRIMARY KEY (address, filter_kind)
);
CREATE TABLE IF NOT EXISTS address_activity_total (
address TEXT PRIMARY KEY,
total_known INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS contract_events (
address TEXT NOT NULL,
event_index INTEGER NOT NULL,
data TEXT NOT NULL,
PRIMARY KEY (address, event_index)
);
CREATE INDEX IF NOT EXISTS idx_contract_events ON contract_events(address);
CREATE TABLE IF NOT EXISTS address_meta_txs (
address TEXT NOT NULL,
tx_hash TEXT NOT NULL,
block_number INTEGER NOT NULL,
data TEXT NOT NULL,
PRIMARY KEY (address, tx_hash)
);
CREATE INDEX IF NOT EXISTS idx_addr_meta_txs
ON address_meta_txs(address, block_number DESC);
CREATE TABLE IF NOT EXISTS class_declarations (
class_hash TEXT PRIMARY KEY,
tx_hash TEXT NOT NULL,
sender TEXT NOT NULL,
block_number INTEGER NOT NULL,
timestamp INTEGER NOT NULL DEFAULT 0
);
CREATE TABLE IF NOT EXISTS class_contracts (
class_hash TEXT NOT NULL,
contract_address TEXT NOT NULL,
block_number INTEGER NOT NULL,
PRIMARY KEY (class_hash, contract_address)
);
CREATE INDEX IF NOT EXISTS idx_class_contracts_class
ON class_contracts(class_hash, block_number DESC);
CREATE TABLE IF NOT EXISTS class_contracts_meta (
class_hash TEXT PRIMARY KEY,
fetched_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS private_notes (
note_id TEXT PRIMARY KEY,
user TEXT NOT NULL,
counterparty TEXT NOT NULL,
direction TEXT NOT NULL,
token TEXT NOT NULL,
amount TEXT NOT NULL,
channel_idx INTEGER NOT NULL,
subchannel_idx INTEGER NOT NULL,
note_idx INTEGER NOT NULL,
spent INTEGER NOT NULL,
block_number INTEGER NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_private_notes_user
ON private_notes(user);
CREATE TABLE IF NOT EXISTS private_nullifiers (
nullifier TEXT PRIMARY KEY,
note_id TEXT NOT NULL,
user TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_private_nullifiers_user
ON private_nullifiers(user);
CREATE TABLE IF NOT EXISTS private_notes_sync (
user TEXT PRIMARY KEY,
last_synced_block INTEGER NOT NULL,
synced_at INTEGER NOT NULL
);
CREATE TABLE IF NOT EXISTS token_metadata (
address TEXT PRIMARY KEY,
symbol TEXT NOT NULL,
decimals INTEGER NOT NULL,
fetched_at INTEGER NOT NULL
);
",
)
.map_err(|e| StarktopError::Config(format!("Failed to init cache schema: {e}")))?;
let version: i64 = db
.query_row("PRAGMA user_version", [], |row| row.get(0))
.unwrap_or(0);
if version < 4 {
db.execute_batch(
"DELETE FROM transactions;
DELETE FROM block_transactions;
DELETE FROM blocks;
DELETE FROM address_txs;
DELETE FROM deploy_info;
PRAGMA user_version = 4;",
)
.map_err(|e| StarktopError::Config(format!("Migration v4 failed: {e}")))?;
debug!("Migration v4: cleared tx/block/address caches");
}
if version < 5 {
db.execute("PRAGMA user_version = 5", []).map_err(|e| {
StarktopError::Config(format!("Migration v5 version bump failed: {e}"))
})?;
debug!("Migration v5: added address_activity_total table");
}
if version < 6 {
db.execute_batch(
"CREATE TABLE address_search_progress_v6 (
address TEXT NOT NULL,
filter_kind TEXT NOT NULL DEFAULT 'unkeyed',
max_searched_block INTEGER NOT NULL,
min_searched_block INTEGER NOT NULL DEFAULT 0,
PRIMARY KEY (address, filter_kind)
);
INSERT INTO address_search_progress_v6
(address, filter_kind, max_searched_block, min_searched_block)
SELECT address, 'unkeyed', max_searched_block, min_searched_block
FROM address_search_progress;
DROP TABLE address_search_progress;
ALTER TABLE address_search_progress_v6
RENAME TO address_search_progress;
PRAGMA user_version = 6;",
)
.map_err(|e| StarktopError::Config(format!("Migration v6 failed: {e}")))?;
debug!("Migration v6: split address_search_progress by filter_kind");
}
if version < 7 {
db.execute("PRAGMA user_version = 7", []).map_err(|e| {
StarktopError::Config(format!("Migration v7 version bump failed: {e}"))
})?;
debug!("Migration v7: added class_history table");
}
if version < 8 {
db.execute("PRAGMA user_version = 8", []).map_err(|e| {
StarktopError::Config(format!("Migration v8 version bump failed: {e}"))
})?;
debug!("Migration v8: added class_history_meta table");
}
if version < 9 {
db.execute("PRAGMA user_version = 9", []).map_err(|e| {
StarktopError::Config(format!("Migration v9 version bump failed: {e}"))
})?;
debug!("Migration v9: added private_notes + private_notes_sync tables");
}
if version < 10 {
db.execute("PRAGMA user_version = 10", []).map_err(|e| {
StarktopError::Config(format!("Migration v10 version bump failed: {e}"))
})?;
debug!("Migration v10: added token_metadata table");
}
if version < 11 {
db.execute_batch(
"DROP TABLE IF EXISTS private_notes;
CREATE TABLE private_notes (
note_id TEXT PRIMARY KEY,
user TEXT NOT NULL,
counterparty TEXT NOT NULL,
direction TEXT NOT NULL,
token TEXT NOT NULL,
amount TEXT NOT NULL,
channel_idx INTEGER NOT NULL,
subchannel_idx INTEGER NOT NULL,
note_idx INTEGER NOT NULL,
spent INTEGER NOT NULL,
block_number INTEGER NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_private_notes_user
ON private_notes(user);
CREATE TABLE IF NOT EXISTS private_nullifiers (
nullifier TEXT PRIMARY KEY,
note_id TEXT NOT NULL,
user TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_private_nullifiers_user
ON private_nullifiers(user);
PRAGMA user_version = 11;",
)
.map_err(|e| StarktopError::Config(format!("Migration v11 failed: {e}")))?;
debug!("Migration v11: reshaped private_notes + added private_nullifiers");
}
let has_tx_hash: i64 = db
.query_row(
"SELECT count(*) FROM pragma_table_info('address_calls') WHERE name = 'tx_hash'",
[],
|r| r.get(0),
)
.map_err(|e| StarktopError::Config(format!("address_calls table_info: {e}")))?;
if has_tx_hash == 0 {
let t0 = std::time::Instant::now();
db.execute_batch(
"BEGIN;
CREATE TABLE address_calls_v2 (
address TEXT NOT NULL,
tx_hash TEXT NOT NULL,
block_number INTEGER NOT NULL,
data TEXT NOT NULL,
PRIMARY KEY (address, tx_hash)
);
INSERT OR REPLACE INTO address_calls_v2 (address, tx_hash, block_number, data)
SELECT address, json_extract(data, '$.tx_hash'),
COALESCE(json_extract(data, '$.block_number'), 0), data
FROM address_calls
WHERE json_valid(data) AND json_extract(data, '$.tx_hash') IS NOT NULL;
DROP TABLE address_calls;
ALTER TABLE address_calls_v2 RENAME TO address_calls;
COMMIT;",
)
.map_err(|e| StarktopError::Config(format!("address_calls re-key failed: {e}")))?;
info!(
elapsed_ms = t0.elapsed().as_millis(),
"Re-keyed address_calls by tx hash"
);
}
let events_has_tx_hash: i64 = db
.query_row(
"SELECT count(*) FROM pragma_table_info('address_events') WHERE name = 'tx_hash'",
[],
|r| r.get(0),
)
.map_err(|e| StarktopError::Config(format!("address_events table_info: {e}")))?;
if events_has_tx_hash == 0 {
eprintln!("starktop: upgrading the event cache (one-time)...");
let t0 = std::time::Instant::now();
db.execute_batch(
"BEGIN;
CREATE TABLE address_events_v2 (
address TEXT NOT NULL,
block_number INTEGER NOT NULL,
tx_hash TEXT NOT NULL,
event_index INTEGER NOT NULL,
data TEXT NOT NULL,
PRIMARY KEY (address, block_number, tx_hash, event_index)
);
INSERT OR REPLACE INTO address_events_v2
(address, block_number, tx_hash, event_index, data)
SELECT address, json_extract(data, '$.block_number'),
json_extract(data, '$.transaction_hash'),
json_extract(data, '$.event_index'), data
FROM address_events
WHERE json_valid(data)
AND json_extract(data, '$.block_number') IS NOT NULL
AND json_extract(data, '$.transaction_hash') IS NOT NULL
AND json_extract(data, '$.event_index') IS NOT NULL
ORDER BY 1, 2, 3, 4;
DROP TABLE address_events;
ALTER TABLE address_events_v2 RENAME TO address_events;
COMMIT;",
)
.map_err(|e| StarktopError::Config(format!("address_events re-key failed: {e}")))?;
info!(
elapsed_ms = t0.elapsed().as_millis(),
"Re-keyed address_events per event"
);
}
drop(db);
Ok(Self {
upstream,
db: pool,
pending_txs: Mutex::new(HashMap::new()),
pending_receipts: Mutex::new(HashMap::new()),
pending_traces: Mutex::new(HashMap::new()),
head: None,
})
}
pub fn with_head_tracker(mut self, head: Arc<dyn crate::data::LatestBlockSource>) -> Self {
self.head = Some(head);
self
}
fn dispatch_write<F>(f: F)
where
F: FnOnce() + Send + 'static,
{
match tokio::runtime::Handle::try_current() {
Ok(handle) => {
handle.spawn_blocking(f);
}
Err(_) => f(),
}
}
fn get_cached_block(&self, number: u64) -> Option<SnBlock> {
let db = self.db.get().ok()?;
let mut stmt = db
.prepare("SELECT data FROM blocks WHERE number = ?1")
.ok()?;
let json: String = stmt.query_row(params![number], |row| row.get(0)).ok()?;
serde_json::from_str(&json).ok()
}
fn cache_block(&self, block: &SnBlock) {
if let Ok(json) = serde_json::to_string(block)
&& let Ok(db) = self.db.get()
{
let _ = db.execute(
"INSERT OR REPLACE INTO blocks (number, data) VALUES (?1, ?2)",
params![block.number, json],
);
if block.hash != Felt::ZERO {
let hash_hex = format!("{:#x}", block.hash);
let _ = db.execute(
"INSERT OR REPLACE INTO block_hash_index (hash, number) VALUES (?1, ?2)",
params![hash_hex, block.number as i64],
);
}
}
}
fn get_cached_block_with_txs(&self, number: u64) -> Option<(SnBlock, Vec<SnTransaction>)> {
let block = self.get_cached_block(number)?;
let db = self.db.get().ok()?;
let mut stmt = db
.prepare(
"SELECT data FROM block_transactions WHERE block_number = ?1 ORDER BY tx_index",
)
.ok()?;
let txs: Vec<SnTransaction> = stmt
.query_map(params![number], |row| {
let json: String = row.get(0)?;
Ok(json)
})
.ok()?
.filter_map(|r| r.ok())
.filter_map(|json| serde_json::from_str(&json).ok())
.collect();
if txs.is_empty() {
return None;
}
Some((block, txs))
}
fn cache_block_with_txs(&self, block: &SnBlock, txs: &[SnTransaction]) {
let block_json = match serde_json::to_string(block) {
Ok(s) => s,
Err(_) => return,
};
let block_number = block.number;
let block_hash_hex = if block.hash != Felt::ZERO {
Some(format!("{:#x}", block.hash))
} else {
None
};
let tx_rows: Vec<(i64, String, String)> = txs
.iter()
.enumerate()
.filter_map(|(i, tx)| {
let json = serde_json::to_string(tx).ok()?;
Some((i as i64, format!("{:#x}", tx.hash()), json))
})
.collect();
let pool = self.db.clone();
Self::dispatch_write(move || {
let mut db = match pool.get() {
Ok(c) => c,
Err(e) => {
warn!(error = %e, "cache_block_with_txs: pool get failed");
return;
}
};
let tx_db = match db.transaction() {
Ok(t) => t,
Err(e) => {
warn!(error = %e, "cache_block_with_txs: begin transaction failed");
return;
}
};
let _ = tx_db.execute(
"INSERT OR REPLACE INTO blocks (number, data) VALUES (?1, ?2)",
params![block_number, block_json],
);
if let Some(hash_hex) = &block_hash_hex {
let _ = tx_db.execute(
"INSERT OR REPLACE INTO block_hash_index (hash, number) VALUES (?1, ?2)",
params![hash_hex, block_number as i64],
);
}
for (i, hash_hex, json) in &tx_rows {
let _ = tx_db.execute(
"INSERT OR REPLACE INTO block_transactions (block_number, tx_index, tx_hash, data) VALUES (?1, ?2, ?3, ?4)",
params![block_number, i, hash_hex, json],
);
let _ = tx_db.execute(
"INSERT OR REPLACE INTO transactions (hash, block_number, data) VALUES (?1, ?2, ?3)",
params![hash_hex, block_number, json],
);
}
if let Err(e) = tx_db.commit() {
warn!(error = %e, "cache_block_with_txs: commit failed");
}
});
}
fn get_cached_transaction(&self, hash: Felt) -> Option<SnTransaction> {
let db = self.db.get().ok()?;
let hash_hex = format!("{:#x}", hash);
let mut stmt = db
.prepare("SELECT data FROM transactions WHERE hash = ?1")
.ok()?;
let json: String = stmt.query_row(params![hash_hex], |row| row.get(0)).ok()?;
serde_json::from_str(&json).ok()
}
fn cache_transaction(&self, tx: &SnTransaction) {
if let Ok(json) = serde_json::to_string(tx)
&& let Ok(db) = self.db.get()
{
let hash_hex = format!("{:#x}", tx.hash());
let _ = db.execute(
"INSERT OR REPLACE INTO transactions (hash, block_number, data) VALUES (?1, ?2, ?3)",
params![hash_hex, 0i64, json],
);
}
}
fn get_cached_address_events(&self, address: &Felt) -> Vec<SnEvent> {
let db = match self.db.get() {
Ok(db) => db,
Err(_) => return Vec::new(),
};
let addr_hex = format!("{:#x}", address);
let mut stmt = match db.prepare(
"SELECT data FROM address_events WHERE address = ?1 \
ORDER BY block_number DESC, tx_hash, event_index DESC",
) {
Ok(s) => s,
Err(_) => return Vec::new(),
};
let rows = match stmt.query_map(params![addr_hex], |row| row.get::<_, String>(0)) {
Ok(r) => r,
Err(_) => return Vec::new(),
};
rows.filter_map(|r| r.ok())
.filter_map(|json| serde_json::from_str(&json).ok())
.collect()
}
fn event_rows(events: &[SnEvent]) -> Vec<(i64, String, i64, String)> {
events
.iter()
.filter_map(|e| {
let json = serde_json::to_string(e).ok()?;
Some((
e.block_number as i64,
format!("{:#x}", e.transaction_hash),
e.event_index as i64,
json,
))
})
.collect()
}
fn upsert_event_rows(
db: &mut rusqlite::Connection,
addr_hex: &str,
rows: &[(i64, String, i64, String)],
) {
Self::retry_locked("address_events", || {
let tx = db.transaction()?;
{
let mut stmt = tx.prepare_cached(
"INSERT OR REPLACE INTO address_events \
(address, block_number, tx_hash, event_index, data) \
VALUES (?1, ?2, ?3, ?4, ?5)",
)?;
for (block, hash, idx, json) in rows {
stmt.execute(params![addr_hex, block, hash, idx, json])?;
}
}
tx.commit()
});
}
fn append_address_events_impl(&self, address: &Felt, events: &[SnEvent]) {
if events.is_empty() {
return;
}
let pool = self.db.clone();
let addr_hex = format!("{:#x}", address);
let rows = Self::event_rows(events);
Self::dispatch_write(move || {
let Ok(mut db) = pool.get() else {
warn!("append_address_events: pool get failed");
return;
};
Self::upsert_event_rows(&mut db, &addr_hex, &rows);
});
}
fn merge_events_dedup(mut fresh: Vec<SnEvent>, cached: Vec<SnEvent>) -> Vec<SnEvent> {
let mut seen: HashSet<(Felt, u64, u64)> =
HashSet::with_capacity(fresh.len() + cached.len());
fresh.retain(|e| seen.insert((e.transaction_hash, e.block_number, e.event_index)));
for e in cached {
if seen.insert((e.transaction_hash, e.block_number, e.event_index)) {
fresh.push(e);
}
}
fresh
}
fn merge_address_events_impl(&self, address: &Felt, new_events: &[SnEvent]) -> Vec<SnEvent> {
if !new_events.is_empty() {
let addr_hex = format!("{:#x}", address);
match self.db.get() {
Ok(mut db) => {
Self::upsert_event_rows(&mut db, &addr_hex, &Self::event_rows(new_events))
}
Err(e) => warn!(error = %e, "merge_address_events: pool get failed"),
}
}
let merged = self.get_cached_address_events(address);
if merged.is_empty() {
return new_events.to_vec();
}
merged
}
fn get_cached_receipt(&self, hash: Felt) -> Option<SnReceipt> {
let db = self.db.get().ok()?;
let hash_hex = format!("{:#x}", hash);
let mut stmt = db
.prepare("SELECT data FROM receipts WHERE tx_hash = ?1")
.ok()?;
let json: String = stmt.query_row(params![hash_hex], |row| row.get(0)).ok()?;
serde_json::from_str(&json).ok()
}
fn cache_receipt(&self, receipt: &SnReceipt) {
if let Ok(json) = serde_json::to_string(receipt)
&& let Ok(db) = self.db.get()
{
let hash_hex = format!("{:#x}", receipt.transaction_hash);
let _ = db.execute(
"INSERT OR REPLACE INTO receipts (tx_hash, data) VALUES (?1, ?2)",
params![hash_hex, json],
);
}
}
fn get_cached_trace(&self, hash: Felt) -> Option<TransactionTrace> {
let db = self.db.get().ok()?;
let hash_hex = format!("{:#x}", hash);
let mut stmt = db
.prepare("SELECT data FROM tx_traces WHERE tx_hash = ?1")
.ok()?;
let json: String = stmt.query_row(params![hash_hex], |row| row.get(0)).ok()?;
serde_json::from_str(&json).ok()
}
fn cache_trace(&self, hash: Felt, trace: &TransactionTrace) {
if let Ok(json) = serde_json::to_string(trace)
&& let Ok(db) = self.db.get()
{
let hash_hex = format!("{:#x}", hash);
let _ = db.execute(
"INSERT OR REPLACE INTO tx_traces (tx_hash, data) VALUES (?1, ?2)",
params![hash_hex, json],
);
}
}
fn get_cached_class_hash(&self, address: &Felt) -> Option<(Felt, u64)> {
let db = self.db.get().ok()?;
let addr_hex = format!("{:#x}", address);
let mut stmt = db
.prepare("SELECT class_hash, fetched_at_block FROM class_hashes WHERE address = ?1")
.ok()?;
stmt.query_row(params![addr_hex], |row| {
let ch_hex: String = row.get(0)?;
let block: i64 = row.get(1)?;
Ok((ch_hex, block as u64))
})
.ok()
.and_then(|(ch_hex, block)| Felt::from_hex(&ch_hex).ok().map(|f| (f, block)))
}
fn cache_class_hash(&self, address: &Felt, class_hash: &Felt, block: u64) {
if let Ok(db) = self.db.get() {
let addr_hex = format!("{:#x}", address);
let ch_hex = format!("{:#x}", class_hash);
let _ = db.execute(
"INSERT OR REPLACE INTO class_hashes (address, class_hash, fetched_at_block) VALUES (?1, ?2, ?3)",
params![addr_hex, ch_hex, block as i64],
);
}
}
fn get_cached_block_number_by_hash(&self, hash: &Felt) -> Option<u64> {
let db = self.db.get().ok()?;
let hash_hex = format!("{:#x}", hash);
let mut stmt = db
.prepare("SELECT number FROM block_hash_index WHERE hash = ?1")
.ok()?;
stmt.query_row(params![hash_hex], |row| {
let n: i64 = row.get(0)?;
Ok(n as u64)
})
.ok()
}
fn cache_block_hash(&self, hash: &Felt, number: u64) {
if let Ok(db) = self.db.get() {
let hash_hex = format!("{:#x}", hash);
let _ = db.execute(
"INSERT OR REPLACE INTO block_hash_index (hash, number) VALUES (?1, ?2)",
params![hash_hex, number as i64],
);
}
}
fn get_cached_deploy_info(&self, address: &Felt) -> Option<(Felt, u64, Option<Felt>)> {
let db = self.db.get().ok()?;
let addr_hex = format!("{:#x}", address);
let mut stmt = db
.prepare(
"SELECT deploy_tx_hash, deploy_block, deployer FROM deploy_info WHERE address = ?1",
)
.ok()?;
stmt.query_row(params![addr_hex], |row| {
let tx_hex: String = row.get(0)?;
let block: i64 = row.get(1)?;
let deployer_hex: Option<String> = row.get(2)?;
Ok((tx_hex, block as u64, deployer_hex))
})
.ok()
.and_then(|(tx_hex, block, deployer_hex)| {
let tx_hash = Felt::from_hex(&tx_hex).ok()?;
let deployer = deployer_hex.and_then(|h| Felt::from_hex(&h).ok());
Some((tx_hash, block, deployer))
})
}
fn cache_deploy_info(
&self,
address: &Felt,
tx_hash: &Felt,
block: u64,
deployer: Option<&Felt>,
) {
if let Ok(db) = self.db.get() {
let addr_hex = format!("{:#x}", address);
let tx_hex = format!("{:#x}", tx_hash);
let deployer_hex = deployer.map(|d| format!("{:#x}", d));
let _ = db.execute(
"INSERT OR REPLACE INTO deploy_info (address, deploy_tx_hash, deploy_block, deployer) VALUES (?1, ?2, ?3, ?4)",
params![addr_hex, tx_hex, block as i64, deployer_hex],
);
}
}
fn get_cached_class_history(
&self,
address: &Felt,
) -> Vec<crate::data::pathfinder::ClassHashEntry> {
let db = match self.db.get() {
Ok(d) => d,
Err(_) => return Vec::new(),
};
let addr_hex = format!("{:#x}", address);
let mut stmt = match db.prepare(
"SELECT block_number, class_hash FROM class_history \
WHERE address = ?1 ORDER BY block_number DESC",
) {
Ok(s) => s,
Err(_) => return Vec::new(),
};
let rows = stmt.query_map(params![addr_hex], |row| {
let block: i64 = row.get(0)?;
let class_hash: String = row.get(1)?;
Ok(crate::data::pathfinder::ClassHashEntry {
block_number: block as u64,
class_hash,
})
});
match rows {
Ok(iter) => iter.filter_map(|r| r.ok()).collect(),
Err(_) => Vec::new(),
}
}
fn cache_class_history(
&self,
address: &Felt,
entries: &[crate::data::pathfinder::ClassHashEntry],
) {
let mut db = match self.db.get() {
Ok(d) => d,
Err(_) => return,
};
let addr_hex = format!("{:#x}", address);
let tx = match db.transaction_with_behavior(TransactionBehavior::Immediate) {
Ok(t) => t,
Err(_) => return,
};
if tx
.execute(
"DELETE FROM class_history WHERE address = ?1",
params![addr_hex],
)
.is_err()
{
return;
}
for entry in entries {
if tx
.execute(
"INSERT OR REPLACE INTO class_history (address, block_number, class_hash) \
VALUES (?1, ?2, ?3)",
params![addr_hex, entry.block_number as i64, entry.class_hash],
)
.is_err()
{
return;
}
}
let _ = tx.commit();
}
fn get_cached_class_history_max_block(&self, address: &Felt) -> Option<u64> {
let db = self.db.get().ok()?;
let addr_hex = format!("{:#x}", address);
let mut stmt = db
.prepare("SELECT last_known_block FROM class_history_meta WHERE address = ?1")
.ok()?;
stmt.query_row(params![addr_hex], |row| {
let block: i64 = row.get(0)?;
Ok(block as u64)
})
.ok()
}
fn cache_class_history_max_block(&self, address: &Felt, block: u64) {
if let Ok(db) = self.db.get() {
let addr_hex = format!("{:#x}", address);
let _ = db.execute(
"INSERT OR REPLACE INTO class_history_meta (address, last_known_block) \
VALUES (?1, ?2)",
params![addr_hex, block as i64],
);
}
}
fn get_cached_nonce_info(&self, address: &Felt) -> Option<(Felt, u64)> {
let db = self.db.get().ok()?;
let addr_hex = format!("{:#x}", address);
let mut stmt = db
.prepare("SELECT nonce, block_number FROM cached_nonces WHERE address = ?1")
.ok()?;
stmt.query_row(params![addr_hex], |row| {
let nonce_hex: String = row.get(0)?;
let block: i64 = row.get(1)?;
Ok((nonce_hex, block as u64))
})
.ok()
.and_then(|(nonce_hex, block)| Felt::from_hex(&nonce_hex).ok().map(|f| (f, block)))
}
fn cache_nonce_info(&self, address: &Felt, nonce: &Felt, block: u64) {
if let Ok(db) = self.db.get() {
let addr_hex = format!("{:#x}", address);
let nonce_hex = format!("{:#x}", nonce);
let _ = db.execute(
"INSERT OR REPLACE INTO cached_nonces (address, nonce, block_number) VALUES (?1, ?2, ?3)",
params![addr_hex, nonce_hex, block as i64],
);
}
}
fn get_cached_search_progress(
&self,
address: &Felt,
filter_kind: FilterKind,
) -> Option<(u64, u64)> {
let db = self.db.get().ok()?;
let addr_hex = format!("{:#x}", address);
let mut stmt = db
.prepare(
"SELECT min_searched_block, max_searched_block FROM address_search_progress \
WHERE address = ?1 AND filter_kind = ?2",
)
.ok()?;
stmt.query_row(params![addr_hex, filter_kind.as_str()], |row| {
let min: i64 = row.get(0)?;
let max: i64 = row.get(1)?;
Ok((min as u64, max as u64))
})
.ok()
}
fn cache_search_progress(
&self,
address: &Felt,
filter_kind: FilterKind,
min_block: u64,
max_block: u64,
) {
if let Ok(db) = self.db.get() {
let addr_hex = format!("{:#x}", address);
let existing = db
.prepare(
"SELECT min_searched_block, max_searched_block FROM address_search_progress \
WHERE address = ?1 AND filter_kind = ?2",
)
.ok()
.and_then(|mut s| {
s.query_row(params![addr_hex, filter_kind.as_str()], |row| {
let min: i64 = row.get(0)?;
let max: i64 = row.get(1)?;
Ok((min as u64, max as u64))
})
.ok()
});
let (final_min, final_max) = if let Some((old_min, old_max)) = existing {
(old_min.min(min_block), old_max.max(max_block))
} else {
(min_block, max_block)
};
let _ = db.execute(
"INSERT OR REPLACE INTO address_search_progress \
(address, filter_kind, min_searched_block, max_searched_block) \
VALUES (?1, ?2, ?3, ?4)",
params![
addr_hex,
filter_kind.as_str(),
final_min as i64,
final_max as i64
],
);
}
}
fn get_cached_activity_total(&self, address: &Felt) -> Option<u64> {
let db = self.db.get().ok()?;
let addr_hex = format!("{:#x}", address);
let mut stmt = db
.prepare("SELECT total_known FROM address_activity_total WHERE address = ?1")
.ok()?;
stmt.query_row(params![addr_hex], |row| row.get::<_, i64>(0))
.ok()
.map(|v| v as u64)
}
fn cache_activity_total(&self, address: &Felt, total: u64) {
if let Ok(db) = self.db.get() {
let addr_hex = format!("{:#x}", address);
let _ = db.execute(
"INSERT OR REPLACE INTO address_activity_total (address, total_known) VALUES (?1, ?2)",
params![addr_hex, total as i64],
);
}
}
fn load_contract_events(&self, address: &Felt) -> Vec<SnEvent> {
let db = match self.db.get() {
Ok(db) => db,
Err(_) => return Vec::new(),
};
let addr_hex = format!("{:#x}", address);
let mut stmt = match db
.prepare("SELECT data FROM contract_events WHERE address = ?1 ORDER BY event_index")
{
Ok(s) => s,
Err(_) => return Vec::new(),
};
let rows = match stmt.query_map(params![addr_hex], |row| row.get::<_, String>(0)) {
Ok(r) => r,
Err(_) => return Vec::new(),
};
rows.filter_map(|r| r.ok())
.filter_map(|json| serde_json::from_str(&json).ok())
.collect()
}
fn save_contract_events(&self, address: &Felt, events: &[SnEvent]) {
let pool = self.db.clone();
let addr_hex = format!("{:#x}", address);
let rows: Vec<(i64, String)> = events
.iter()
.enumerate()
.filter_map(|(i, e)| serde_json::to_string(e).ok().map(|j| (i as i64, j)))
.collect();
Self::dispatch_write(move || {
if let Ok(mut db) = pool.get() {
let tx = match db.transaction() {
Ok(t) => t,
Err(e) => {
warn!(error = %e, "save_contract_events: begin transaction failed");
return;
}
};
let _ = tx.execute(
"DELETE FROM contract_events WHERE address = ?1",
params![&addr_hex],
);
for (i, json) in &rows {
let _ = tx.execute(
"INSERT OR REPLACE INTO contract_events (address, event_index, data) VALUES (?1, ?2, ?3)",
params![&addr_hex, i, json],
);
}
if let Err(e) = tx.commit() {
warn!(error = %e, "save_contract_events: commit failed");
}
}
});
}
}
impl CachingDataSource {
fn retry_locked(label: &str, mut f: impl FnMut() -> rusqlite::Result<()>) {
const ATTEMPTS: u32 = 40;
for attempt in 1..=ATTEMPTS {
match f() {
Ok(()) => return,
Err(e) if attempt < ATTEMPTS && Self::is_locked(&e) => {
std::thread::sleep(std::time::Duration::from_millis(250));
}
Err(e) => {
warn!(error = %e, label, attempt, "cache write failed");
return;
}
}
}
}
fn is_locked(e: &rusqlite::Error) -> bool {
matches!(
e,
rusqlite::Error::SqliteFailure(f, _)
if matches!(
f.code,
rusqlite::ErrorCode::DatabaseBusy | rusqlite::ErrorCode::DatabaseLocked
)
)
}
fn load_scanned_ranges(&self, table: &str, address: &Felt) -> Vec<(u64, u64)> {
let db = match self.db.get() {
Ok(db) => db,
Err(_) => return Vec::new(),
};
let addr_hex = format!("{:#x}", address);
let sql =
format!("SELECT lo_block, hi_block FROM {table} WHERE address = ?1 ORDER BY lo_block");
let mut stmt = match db.prepare(&sql) {
Ok(s) => s,
Err(_) => return Vec::new(),
};
let rows = match stmt.query_map(params![addr_hex], |row| {
Ok((row.get::<_, i64>(0)?, row.get::<_, i64>(1)?))
}) {
Ok(r) => r,
Err(_) => return Vec::new(),
};
rows.filter_map(|r| r.ok())
.map(|(lo, hi)| (lo as u64, hi as u64))
.collect()
}
fn add_scanned_range(&self, table: &'static str, address: &Felt, lo: u64, hi: u64) {
let pool = self.db.clone();
let addr_hex = format!("{:#x}", address);
Self::dispatch_write(move || {
let Ok(mut db) = pool.get() else {
warn!(table, "add_scanned_range: pool get failed");
return;
};
Self::retry_locked(table, || {
let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?;
let mut ranges: Vec<(u64, u64)> = tx
.prepare(&format!(
"SELECT lo_block, hi_block FROM {table} WHERE address = ?1"
))?
.query_map(params![&addr_hex], |row| {
Ok((row.get::<_, i64>(0)? as u64, row.get::<_, i64>(1)? as u64))
})?
.collect::<rusqlite::Result<Vec<_>>>()?;
crate::utils::merge_block_interval(&mut ranges, lo, hi);
tx.execute(
&format!("DELETE FROM {table} WHERE address = ?1"),
params![&addr_hex],
)?;
for (rlo, rhi) in &ranges {
tx.execute(
&format!(
"INSERT OR REPLACE INTO {table} (address, lo_block, hi_block) VALUES (?1, ?2, ?3)"
),
params![&addr_hex, *rlo as i64, *rhi as i64],
)?;
}
tx.commit()
});
});
}
}
#[async_trait]
impl DataSource for CachingDataSource {
async fn get_latest_block_number(&self) -> Result<u64> {
self.upstream.get_latest_block_number().await
}
async fn latest_block_hint(&self) -> Option<u64> {
if let Some(head) = &self.head
&& let Some(block) = head.latest()
{
return Some(block);
}
match self.upstream.get_latest_block_number().await {
Ok(n) => Some(n),
Err(e) => {
debug!(error = %e, "latest_block_hint: upstream get_latest_block_number failed");
None
}
}
}
async fn get_block(&self, number: u64) -> Result<SnBlock> {
if let Some(mut block) = self.get_cached_block(number) {
if is_final_status(&block.status) {
trace!(number, "cache hit: block (final)");
return Ok(block);
}
match self.upstream.get_block_status(number).await {
Ok(status) => {
if status != block.status {
debug!(number, %status, "block status advanced, updating cache");
block.status = status;
self.cache_block(&block);
}
return Ok(block);
}
Err(e) => {
debug!(number, error = %e, "block status probe failed, serving cached");
return Ok(block);
}
}
}
debug!(number, "cache miss: block, fetching from RPC");
let block = self.upstream.get_block(number).await?;
self.cache_block(&block);
Ok(block)
}
async fn get_block_by_hash(&self, hash: Felt) -> Result<u64> {
if let Some(number) = self.get_cached_block_number_by_hash(&hash) {
trace!(hash = %format!("{:#x}", hash), "cache hit: block_by_hash");
return Ok(number);
}
let number = self.upstream.get_block_by_hash(hash).await?;
self.cache_block_hash(&hash, number);
Ok(number)
}
async fn get_block_with_txs(&self, number: u64) -> Result<(SnBlock, Vec<SnTransaction>)> {
if let Some((mut block, txs)) = self.get_cached_block_with_txs(number) {
if is_final_status(&block.status) {
trace!(number, tx_count = txs.len(), "cache hit: block+txs (final)");
return Ok((block, txs));
}
match self.upstream.get_block_status(number).await {
Ok(status) => {
if status != block.status {
debug!(number, %status, "block status advanced, updating cache");
block.status = status;
self.cache_block(&block);
}
}
Err(e) => {
debug!(number, error = %e, "block status probe failed, serving cached");
}
}
return Ok((block, txs));
}
debug!(number, "cache miss: block+txs, fetching from RPC");
let (block, txs) = self.upstream.get_block_with_txs(number).await?;
self.cache_block_with_txs(&block, &txs);
Ok((block, txs))
}
async fn get_transaction(&self, hash: Felt) -> Result<SnTransaction> {
if let Some(tx) = self.get_cached_transaction(hash) {
trace!(tx_hash = %format!("{:#x}", hash), "cache hit: transaction");
return Ok(tx);
}
let fut = {
let mut pending = self.pending_txs.lock().unwrap();
if let Some(existing) = pending.get(&hash) {
trace!(tx_hash = %format!("{:#x}", hash), "dedup: joining in-flight transaction fetch");
existing.clone()
} else {
debug!(tx_hash = %format!("{:#x}", hash), "cache miss: transaction, fetching from RPC");
let upstream = Arc::clone(&self.upstream);
let fut: Pin<
Box<dyn Future<Output = std::result::Result<SnTransaction, String>> + Send>,
> = Box::pin(async move {
upstream
.get_transaction(hash)
.await
.map_err(|e| e.to_string())
});
let shared = fut.shared();
pending.insert(hash, shared.clone());
shared
}
};
let result = fut.await;
{
let mut pending = self.pending_txs.lock().unwrap();
pending.remove(&hash);
}
match result {
Ok(tx) => {
self.cache_transaction(&tx);
Ok(tx)
}
Err(e) => Err(StarktopError::Rpc(e)),
}
}
async fn get_receipt(&self, hash: Felt) -> Result<SnReceipt> {
if let Some(receipt) = self.get_cached_receipt(hash) {
trace!(tx_hash = %format!("{:#x}", hash), "cache hit: receipt");
return Ok(receipt);
}
let fut = {
let mut pending = self.pending_receipts.lock().unwrap();
if let Some(existing) = pending.get(&hash) {
trace!(tx_hash = %format!("{:#x}", hash), "dedup: joining in-flight receipt fetch");
existing.clone()
} else {
debug!(tx_hash = %format!("{:#x}", hash), "cache miss: receipt, fetching from RPC");
let upstream = Arc::clone(&self.upstream);
let fut: Pin<
Box<dyn Future<Output = std::result::Result<SnReceipt, String>> + Send>,
> = Box::pin(
async move { upstream.get_receipt(hash).await.map_err(|e| e.to_string()) },
);
let shared = fut.shared();
pending.insert(hash, shared.clone());
shared
}
};
let result = fut.await;
{
let mut pending = self.pending_receipts.lock().unwrap();
pending.remove(&hash);
}
match result {
Ok(receipt) => {
self.cache_receipt(&receipt);
Ok(receipt)
}
Err(e) => Err(StarktopError::Rpc(e)),
}
}
async fn get_nonce(&self, address: Felt) -> Result<Felt> {
self.upstream.get_nonce(address).await
}
async fn get_class_hash(&self, address: Felt) -> Result<Felt> {
const CLASS_HASH_STALE_BLOCKS: u64 = 1000;
if let Some((class_hash, fetched_at)) = self.get_cached_class_hash(&address) {
let latest = self.latest_block_hint().await.unwrap_or(0);
let age = latest.saturating_sub(fetched_at);
if age < CLASS_HASH_STALE_BLOCKS {
trace!(address = %format!("{:#x}", address), "cache hit: class_hash");
return Ok(class_hash);
}
debug!(address = %format!("{:#x}", address), age, "class_hash cache stale, refetching");
}
let class_hash = self.upstream.get_class_hash(address).await?;
if let Some(block) = self.latest_block_hint().await {
self.cache_class_hash(&address, &class_hash, block);
}
Ok(class_hash)
}
async fn get_class_hash_at(&self, address: Felt, block: u64) -> Result<Felt> {
self.upstream.get_class_hash_at(address, block).await
}
async fn get_class(&self, class_hash: Felt) -> Result<ContractClass> {
debug!(class_hash = %format!("{:#x}", class_hash), "Fetching class from RPC (not cached — parsed ABI cached separately)");
self.upstream.get_class(class_hash).await
}
async fn get_trace(&self, hash: Felt) -> Result<TransactionTrace> {
if let Some(cached) = self.get_cached_trace(hash) {
trace!(tx_hash = %format!("{:#x}", hash), "cache hit: trace");
return Ok(cached);
}
let fut = {
let mut pending = self.pending_traces.lock().unwrap();
if let Some(existing) = pending.get(&hash) {
trace!(tx_hash = %format!("{:#x}", hash), "dedup: joining in-flight trace fetch");
existing.clone()
} else {
debug!(tx_hash = %format!("{:#x}", hash), "cache miss: trace, fetching from RPC");
let upstream = Arc::clone(&self.upstream);
let fut: Pin<
Box<dyn Future<Output = std::result::Result<TransactionTrace, String>> + Send>,
> = Box::pin(
async move { upstream.get_trace(hash).await.map_err(|e| e.to_string()) },
);
let shared = fut.shared();
pending.insert(hash, shared.clone());
shared
}
};
let result = fut.await;
{
let mut pending = self.pending_traces.lock().unwrap();
pending.remove(&hash);
}
match result {
Ok(fetched) => {
self.cache_trace(hash, &fetched);
Ok(fetched)
}
Err(e) => Err(StarktopError::Rpc(e)),
}
}
async fn get_events_for_address(
&self,
address: Felt,
from_block: Option<u64>,
to_block: Option<u64>,
limit: usize,
) -> Result<Vec<SnEvent>> {
if to_block.is_some() {
return self
.upstream
.get_events_for_address(address, from_block, to_block, limit)
.await;
}
let cached = self.get_cached_address_events(&address);
let fetch_from = if !cached.is_empty() && from_block.is_none() {
let max_block = cached.iter().map(|e| e.block_number).max().unwrap_or(0);
Some(max_block + 1)
} else {
from_block
};
let new_events = self
.upstream
.get_events_for_address(address, fetch_from, None, limit)
.await
.unwrap_or_default();
self.append_address_events_impl(&address, &new_events);
let mut merged = Self::merge_events_dedup(new_events, cached);
merged.sort_by(|a, b| b.block_number.cmp(&a.block_number));
Ok(merged)
}
fn load_cached_address_txs(&self, address: &Felt) -> Vec<AddressTxSummary> {
let db = match self.db.get() {
Ok(db) => db,
Err(_) => return Vec::new(),
};
let addr_hex = format!("{:#x}", address);
let mut stmt =
match db.prepare("SELECT data FROM address_txs WHERE address = ?1 ORDER BY tx_index") {
Ok(s) => s,
Err(_) => return Vec::new(),
};
let rows = match stmt.query_map(params![addr_hex], |row| row.get::<_, String>(0)) {
Ok(r) => r,
Err(_) => return Vec::new(),
};
rows.filter_map(|r| r.ok())
.filter_map(|json| serde_json::from_str(&json).ok())
.collect()
}
fn save_address_txs(&self, address: &Felt, txs: &[AddressTxSummary]) {
let pool = self.db.clone();
let addr_hex = format!("{:#x}", address);
let rows: Vec<(i64, String)> = txs
.iter()
.enumerate()
.filter_map(|(i, tx)| serde_json::to_string(tx).ok().map(|j| (i as i64, j)))
.collect();
Self::dispatch_write(move || {
if let Ok(mut db) = pool.get() {
let tx_db = match db.transaction() {
Ok(t) => t,
Err(e) => {
warn!(error = %e, "save_address_txs: begin transaction failed");
return;
}
};
let _ = tx_db.execute(
"DELETE FROM address_txs WHERE address = ?1",
params![&addr_hex],
);
for (i, json) in &rows {
let _ = tx_db.execute(
"INSERT OR REPLACE INTO address_txs (address, tx_index, data) VALUES (?1, ?2, ?3)",
params![&addr_hex, i, json],
);
}
if let Err(e) = tx_db.commit() {
warn!(error = %e, "save_address_txs: commit failed");
}
}
});
}
fn load_cached_address_calls(&self, address: &Felt) -> Vec<ContractCallSummary> {
let db = match self.db.get() {
Ok(db) => db,
Err(_) => return Vec::new(),
};
let addr_hex = format!("{:#x}", address);
let mut stmt = match db
.prepare("SELECT data FROM address_calls WHERE address = ?1 ORDER BY block_number DESC")
{
Ok(s) => s,
Err(_) => return Vec::new(),
};
let rows = match stmt.query_map(params![addr_hex], |row| row.get::<_, String>(0)) {
Ok(r) => r,
Err(_) => return Vec::new(),
};
rows.filter_map(|r| r.ok())
.filter_map(|json| serde_json::from_str(&json).ok())
.collect()
}
fn save_address_calls(&self, address: &Felt, calls: &[ContractCallSummary]) {
let pool = self.db.clone();
let addr_hex = format!("{:#x}", address);
let rows: Vec<(String, i64, String)> = calls
.iter()
.filter_map(|c| {
serde_json::to_string(c)
.ok()
.map(|j| (format!("{:#x}", c.tx_hash), c.block_number as i64, j))
})
.collect();
debug!(address = %addr_hex, rows = rows.len(), "save_address_calls: upsert");
Self::dispatch_write(move || {
if let Ok(mut db) = pool.get() {
let tx = match db.transaction() {
Ok(t) => t,
Err(e) => {
warn!(error = %e, "save_address_calls: begin transaction failed");
return;
}
};
{
let mut stmt = match tx.prepare_cached(
"INSERT OR REPLACE INTO address_calls (address, tx_hash, block_number, data) VALUES (?1, ?2, ?3, ?4)",
) {
Ok(s) => s,
Err(e) => {
warn!(error = %e, "save_address_calls: prepare failed");
return;
}
};
for (hash, block, json) in &rows {
let _ = stmt.execute(params![&addr_hex, hash, block, json]);
}
}
if let Err(e) = tx.commit() {
warn!(error = %e, "save_address_calls: commit failed");
}
}
});
}
fn load_call_scanned_ranges(&self, address: &Felt) -> Vec<(u64, u64)> {
self.load_scanned_ranges("address_call_scanned_ranges", address)
}
fn add_call_scanned_range(&self, address: &Felt, lo: u64, hi: u64) {
self.add_scanned_range("address_call_scanned_ranges", address, lo, hi);
}
fn load_transfer_scanned_ranges(&self, address: &Felt) -> Vec<(u64, u64)> {
self.load_scanned_ranges("address_transfer_scanned_ranges", address)
}
fn add_transfer_scanned_range(&self, address: &Felt, lo: u64, hi: u64) {
self.add_scanned_range("address_transfer_scanned_ranges", address, lo, hi);
}
fn load_cached_transfers(&self, address: &Felt) -> Vec<TokenTransfer> {
let db = match self.db.get() {
Ok(db) => db,
Err(_) => return Vec::new(),
};
let addr_hex = format!("{:#x}", address);
let mut stmt = match db.prepare(
"SELECT data FROM address_transfers WHERE address = ?1 ORDER BY block_number DESC",
) {
Ok(s) => s,
Err(_) => return Vec::new(),
};
let rows = match stmt.query_map(params![addr_hex], |row| row.get::<_, String>(0)) {
Ok(r) => r,
Err(_) => return Vec::new(),
};
let mut out: Vec<TokenTransfer> = rows
.filter_map(|r| r.ok())
.filter_map(|json| serde_json::from_str(&json).ok())
.collect();
out.sort_by(TokenTransfer::cmp_newest_first);
out
}
fn save_transfers(&self, address: &Felt, rows: &[TokenTransfer]) {
let pool = self.db.clone();
let addr_hex = format!("{:#x}", address);
let encoded: Vec<(String, i64, i64, String)> = rows
.iter()
.filter_map(|t| {
serde_json::to_string(t).ok().map(|j| {
(
format!("{:#x}", t.tx_hash),
t.event_index as i64,
t.block_number as i64,
j,
)
})
})
.collect();
Self::dispatch_write(move || {
let Ok(mut db) = pool.get() else {
warn!("save_transfers: pool get failed");
return;
};
Self::retry_locked("save_transfers", || {
let tx = db.transaction_with_behavior(TransactionBehavior::Immediate)?;
{
let mut stmt = tx.prepare_cached(
"INSERT OR REPLACE INTO address_transfers \
(address, tx_hash, event_index, block_number, data) VALUES (?1, ?2, ?3, ?4, ?5)",
)?;
for (hash, idx, block, json) in &encoded {
stmt.execute(params![&addr_hex, hash, idx, block, json])?;
}
}
tx.commit()
});
});
}
fn load_cached_meta_txs(&self, address: &Felt) -> Vec<MetaTxIntenderSummary> {
let db = match self.db.get() {
Ok(db) => db,
Err(_) => return Vec::new(),
};
let addr_hex = format!("{:#x}", address);
let mut stmt = match db.prepare(
"SELECT data FROM address_meta_txs WHERE address = ?1 ORDER BY block_number DESC",
) {
Ok(s) => s,
Err(_) => return Vec::new(),
};
let rows = match stmt.query_map(params![addr_hex], |row| row.get::<_, String>(0)) {
Ok(r) => r,
Err(_) => return Vec::new(),
};
rows.filter_map(|r| r.ok())
.filter_map(|json| serde_json::from_str(&json).ok())
.collect()
}
fn save_meta_txs(&self, address: &Felt, txs: &[MetaTxIntenderSummary]) {
if let Ok(mut db) = self.db.get() {
let addr_hex = format!("{:#x}", address);
let tx_db = match db.transaction() {
Ok(t) => t,
Err(e) => {
warn!(error = %e, "save_meta_txs: begin transaction failed");
return;
}
};
for tx in txs {
if let Ok(json) = serde_json::to_string(tx) {
let hash_hex = format!("{:#x}", tx.hash);
let _ = tx_db.execute(
"INSERT OR REPLACE INTO address_meta_txs \
(address, tx_hash, block_number, data) VALUES (?1, ?2, ?3, ?4)",
params![addr_hex, hash_hex, tx.block_number as i64, json],
);
}
}
if let Err(e) = tx_db.commit() {
warn!(error = %e, "save_meta_txs: commit failed");
}
}
}
fn load_cached_activity_range(&self, address: &Felt) -> Option<(u64, u64)> {
self.load_cached_activity_range_with_count(address)
.map(|(min, max, _count)| (min, max))
}
fn load_cached_activity_range_with_count(&self, address: &Felt) -> Option<(u64, u64, u64)> {
let db = self.db.get().ok()?;
let addr_hex = format!("{:#x}", address);
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.ok()?
.as_secs() as i64;
let cutoff = now - 3600;
let mut stmt = db
.prepare(
"SELECT min_block, max_block, event_count FROM address_activity \
WHERE address = ?1 AND updated_at > ?2",
)
.ok()?;
stmt.query_row(params![addr_hex, cutoff], |row| {
let min: i64 = row.get(0)?;
let max: i64 = row.get(1)?;
let count: i64 = row.get(2)?;
Ok((min as u64, max as u64, count as u64))
})
.ok()
}
fn load_cached_activity_range_any_age(&self, address: &Felt) -> Option<(u64, u64, u64)> {
let db = self.db.get().ok()?;
let addr_hex = format!("{:#x}", address);
let mut stmt = db
.prepare(
"SELECT min_block, max_block, event_count FROM address_activity \
WHERE address = ?1",
)
.ok()?;
stmt.query_row(params![addr_hex], |row| {
let min: i64 = row.get(0)?;
let max: i64 = row.get(1)?;
let count: i64 = row.get(2)?;
Ok((min as u64, max as u64, count as u64))
})
.ok()
}
fn save_activity_range(&self, address: &Felt, min_block: u64, max_block: u64) {
self.save_activity_range_with_count(address, min_block, max_block, 0);
}
fn save_activity_range_with_count(
&self,
address: &Felt,
min_block: u64,
max_block: u64,
event_count: u64,
) {
if let Ok(db) = self.db.get() {
let addr_hex = format!("{:#x}", address);
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_secs() as i64;
let existing = db
.prepare(
"SELECT min_block, max_block, event_count FROM address_activity WHERE address = ?1",
)
.ok()
.and_then(|mut s| {
s.query_row(params![addr_hex], |row| {
let min: i64 = row.get(0)?;
let max: i64 = row.get(1)?;
let count: i64 = row.get(2)?;
Ok((min as u64, max as u64, count as u64))
})
.ok()
});
let (final_min, final_max, final_count) =
if let Some((old_min, old_max, old_count)) = existing {
(
old_min.min(min_block),
old_max.max(max_block),
old_count.max(event_count),
)
} else {
(min_block, max_block, event_count)
};
let _ = db.execute(
"INSERT OR REPLACE INTO address_activity (address, min_block, max_block, event_count, updated_at) \
VALUES (?1, ?2, ?3, ?4, ?5)",
params![addr_hex, final_min as i64, final_max as i64, final_count as i64, now],
);
}
}
async fn call_contract(
&self,
contract_address: Felt,
selector: Felt,
calldata: Vec<Felt>,
) -> Result<Vec<Felt>> {
self.upstream
.call_contract(contract_address, selector, calldata)
.await
}
async fn batch_call_contracts(
&self,
calls: Vec<(Felt, Felt, Vec<Felt>)>,
) -> Vec<Result<Vec<Felt>>> {
self.upstream.batch_call_contracts(calls).await
}
async fn get_storage_at(&self, contract: Felt, key: Felt, block: Option<u64>) -> Result<Felt> {
self.upstream.get_storage_at(contract, key, block).await
}
async fn batch_get_storage_at(
&self,
contract: Felt,
keys: &[Felt],
block: Option<u64>,
) -> Vec<Result<Felt>> {
self.upstream
.batch_get_storage_at(contract, keys, block)
.await
}
async fn get_transfer_events(
&self,
address: Felt,
from_block: u64,
to_block: u64,
) -> Result<Vec<TokenTransfer>> {
self.upstream
.get_transfer_events(address, from_block, to_block)
.await
}
async fn get_contract_events(
&self,
address: Felt,
from_block: Option<u64>,
to_block: Option<u64>,
limit: usize,
) -> Result<Vec<SnEvent>> {
if to_block.is_some() {
return self
.upstream
.get_contract_events(address, from_block, to_block, limit)
.await;
}
let cached = self.load_contract_events(&address);
let fetch_from = if !cached.is_empty() && from_block.is_none() {
let max_block = cached.iter().map(|e| e.block_number).max().unwrap_or(0);
Some(max_block + 1)
} else {
from_block
};
let new_events = match self
.upstream
.get_contract_events(address, fetch_from, None, limit)
.await
{
Ok(events) => events,
Err(e) => {
warn!(address = %format!("{:#x}", address), error = %e, "RPC error fetching events, using cache only");
if cached.is_empty() {
return Err(e);
}
vec![]
}
};
let mut merged = Self::merge_events_dedup(new_events, cached);
merged.sort_by(|a, b| b.block_number.cmp(&a.block_number));
self.save_contract_events(&address, &merged);
merged.truncate(limit);
Ok(merged)
}
fn load_cached_deploy_info(&self, address: &Felt) -> Option<(Felt, u64, Option<Felt>)> {
self.get_cached_deploy_info(address)
}
fn save_deploy_info(
&self,
address: &Felt,
tx_hash: &Felt,
block: u64,
deployer: Option<&Felt>,
) {
self.cache_deploy_info(address, tx_hash, block, deployer);
}
fn load_cached_class_history(
&self,
address: &Felt,
) -> Vec<crate::data::pathfinder::ClassHashEntry> {
self.get_cached_class_history(address)
}
fn save_class_history(
&self,
address: &Felt,
entries: &[crate::data::pathfinder::ClassHashEntry],
) {
self.cache_class_history(address, entries);
}
fn load_class_history_max_block(&self, address: &Felt) -> Option<u64> {
self.get_cached_class_history_max_block(address)
}
fn save_class_history_max_block(&self, address: &Felt, block: u64) {
self.cache_class_history_max_block(address, block);
}
fn load_cached_nonce(&self, address: &Felt) -> Option<(Felt, u64)> {
self.get_cached_nonce_info(address)
}
fn save_cached_nonce(&self, address: &Felt, nonce: &Felt, block: u64) {
self.cache_nonce_info(address, nonce, block);
}
fn load_cached_class_hash(&self, address: &Felt) -> Option<Felt> {
self.get_cached_class_hash(address).map(|(ch, _)| ch)
}
fn load_search_progress(&self, address: &Felt, filter_kind: FilterKind) -> Option<(u64, u64)> {
self.get_cached_search_progress(address, filter_kind)
}
fn save_search_progress(
&self,
address: &Felt,
filter_kind: FilterKind,
min_block: u64,
max_block: u64,
) {
self.cache_search_progress(address, filter_kind, min_block, max_block);
}
fn load_activity_total(&self, address: &Felt) -> Option<u64> {
self.get_cached_activity_total(address)
}
fn save_activity_total(&self, address: &Felt, total: u64) {
self.cache_activity_total(address, total);
}
fn load_address_events(&self, address: &Felt) -> Vec<SnEvent> {
self.get_cached_address_events(address)
}
fn merge_address_events(&self, address: &Felt, new_events: &[SnEvent]) -> Vec<SnEvent> {
self.merge_address_events_impl(address, new_events)
}
fn append_address_events(&self, address: &Felt, events: &[SnEvent]) {
self.append_address_events_impl(address, events);
}
async fn get_recent_blocks(&self, count: usize) -> Result<Vec<SnBlock>> {
let blocks = self.upstream.get_recent_blocks(count).await?;
for block in &blocks {
self.cache_block(block);
}
Ok(blocks)
}
fn load_cached_class_declaration(&self, class_hash: &Felt) -> Option<ClassDeclareInfo> {
let db = self.db.get().ok()?;
let hash_hex = format!("{:#x}", class_hash);
let mut stmt = db
.prepare(
"SELECT tx_hash, sender, block_number, timestamp \
FROM class_declarations WHERE class_hash = ?1",
)
.ok()?;
stmt.query_row(params![hash_hex], |row| {
let tx_hash_s: String = row.get(0)?;
let sender_s: String = row.get(1)?;
let block_number: i64 = row.get(2)?;
let timestamp: i64 = row.get(3)?;
Ok((tx_hash_s, sender_s, block_number as u64, timestamp as u64))
})
.ok()
.and_then(|(tx_hash_s, sender_s, block_number, timestamp)| {
let tx_hash = Felt::from_hex(&tx_hash_s).ok()?;
let sender = Felt::from_hex(&sender_s).ok()?;
Some(ClassDeclareInfo {
tx_hash,
sender,
block_number,
timestamp,
})
})
}
fn save_class_declaration(&self, class_hash: &Felt, info: &ClassDeclareInfo) {
if let Ok(db) = self.db.get() {
let hash_hex = format!("{:#x}", class_hash);
let tx_hex = format!("{:#x}", info.tx_hash);
let sender_hex = format!("{:#x}", info.sender);
let _ = db.execute(
"INSERT OR REPLACE INTO class_declarations \
(class_hash, tx_hash, sender, block_number, timestamp) \
VALUES (?1, ?2, ?3, ?4, ?5)",
params![
hash_hex,
tx_hex,
sender_hex,
info.block_number as i64,
info.timestamp as i64,
],
);
}
}
fn load_cached_class_contracts(&self, class_hash: &Felt) -> Option<Vec<ClassContractEntry>> {
let db = self.db.get().ok()?;
let hash_hex = format!("{:#x}", class_hash);
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.ok()?
.as_secs() as i64;
let cutoff = now - 3600;
let fetched_at: i64 = db
.prepare("SELECT fetched_at FROM class_contracts_meta WHERE class_hash = ?1")
.ok()?
.query_row(params![&hash_hex], |row| row.get(0))
.ok()?;
if fetched_at <= cutoff {
return None;
}
let mut stmt = db
.prepare(
"SELECT contract_address, block_number FROM class_contracts \
WHERE class_hash = ?1 ORDER BY block_number DESC",
)
.ok()?;
let rows = stmt
.query_map(params![hash_hex], |row| {
let addr_s: String = row.get(0)?;
let block_number: i64 = row.get(1)?;
Ok((addr_s, block_number as u64))
})
.ok()?;
let mut out = Vec::new();
for row in rows.flatten() {
if let Ok(address) = Felt::from_hex(&row.0) {
out.push(ClassContractEntry {
address,
block_number: row.1,
});
}
}
Some(out)
}
fn save_class_contracts(&self, class_hash: &Felt, contracts: &[ClassContractEntry]) {
if let Ok(mut db) = self.db.get() {
let hash_hex = format!("{:#x}", class_hash);
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_secs() as i64;
let tx = match db.transaction() {
Ok(t) => t,
Err(e) => {
warn!(error = %e, "save_class_contracts: begin transaction failed");
return;
}
};
let _ = tx.execute(
"DELETE FROM class_contracts WHERE class_hash = ?1",
params![hash_hex],
);
for entry in contracts {
let contract_hex = format!("{:#x}", entry.address);
let _ = tx.execute(
"INSERT OR REPLACE INTO class_contracts \
(class_hash, contract_address, block_number) VALUES (?1, ?2, ?3)",
params![hash_hex, contract_hex, entry.block_number as i64],
);
}
let _ = tx.execute(
"INSERT OR REPLACE INTO class_contracts_meta (class_hash, fetched_at) \
VALUES (?1, ?2)",
params![hash_hex, now],
);
if let Err(e) = tx.commit() {
warn!(error = %e, "save_class_contracts: commit failed");
}
}
}
fn load_token_metadata(&self) -> Vec<(Felt, crate::data::token_metadata::TokenMeta)> {
let db = match self.db.get() {
Ok(db) => db,
Err(_) => return Vec::new(),
};
let mut stmt = match db.prepare("SELECT address, symbol, decimals FROM token_metadata") {
Ok(s) => s,
Err(_) => return Vec::new(),
};
let rows = match stmt.query_map([], |row| {
Ok((
row.get::<_, String>(0)?,
row.get::<_, String>(1)?,
row.get::<_, i64>(2)?,
))
}) {
Ok(r) => r,
Err(_) => return Vec::new(),
};
rows.filter_map(|r| r.ok())
.filter_map(|(addr, sym, dec)| {
let felt = Felt::from_hex(&addr).ok()?;
if !(0..=255).contains(&dec) {
return None;
}
Some((
felt,
crate::data::token_metadata::TokenMeta {
symbol: sym,
decimals: dec as u8,
},
))
})
.collect()
}
fn save_token_metadata(&self, address: &Felt, meta: &crate::data::token_metadata::TokenMeta) {
if let Ok(db) = self.db.get() {
let addr_hex = format!("{:#x}", address);
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.unwrap_or(0);
if let Err(e) = db.execute(
"INSERT OR REPLACE INTO token_metadata
(address, symbol, decimals, fetched_at)
VALUES (?1, ?2, ?3, ?4)",
params![addr_hex, meta.symbol, meta.decimals as i64, now],
) {
warn!(error = %e, "save_token_metadata failed");
}
}
}
fn load_private_notes(
&self,
) -> (
Vec<crate::decode::privacy_sync::DecryptedNote>,
Vec<(Felt, Felt)>,
) {
use crate::decode::privacy_sync::{DecryptedNote, NoteDirection};
let db = match self.db.get() {
Ok(db) => db,
Err(_) => return (Vec::new(), Vec::new()),
};
let notes: Vec<DecryptedNote> = match db.prepare(
"SELECT note_id, user, counterparty, direction, token, amount,
channel_idx, subchannel_idx, note_idx, spent, block_number
FROM private_notes",
) {
Ok(mut stmt) => match stmt.query_map([], |row| {
Ok((
row.get::<_, String>(0)?,
row.get::<_, String>(1)?,
row.get::<_, String>(2)?,
row.get::<_, String>(3)?,
row.get::<_, String>(4)?,
row.get::<_, String>(5)?,
row.get::<_, i64>(6)?,
row.get::<_, i64>(7)?,
row.get::<_, i64>(8)?,
row.get::<_, i64>(9)?,
row.get::<_, i64>(10)?,
))
}) {
Ok(rows) => rows
.filter_map(|r| r.ok())
.filter_map(|(nid, u, cp, dir, tok, amt, ch, sch, ni, sp, bn)| {
let direction = match dir.as_str() {
"incoming" => NoteDirection::Incoming,
"outgoing" => NoteDirection::Outgoing,
_ => return None,
};
Some(DecryptedNote {
note_id: Felt::from_hex(&nid).ok()?,
user: Felt::from_hex(&u).ok()?,
counterparty: Felt::from_hex(&cp).ok()?,
direction,
token: Felt::from_hex(&tok).ok()?,
amount: amt.parse::<u128>().ok()?,
channel_idx: ch.max(0) as u64,
subchannel_idx: sch.max(0) as u64,
note_idx: ni.max(0) as u64,
spent: sp != 0,
block_number: bn.max(0) as u64,
})
})
.collect(),
Err(_) => Vec::new(),
},
Err(_) => Vec::new(),
};
let nullifiers: Vec<(Felt, Felt)> =
match db.prepare("SELECT nullifier, note_id FROM private_nullifiers") {
Ok(mut stmt) => match stmt.query_map([], |row| {
Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
}) {
Ok(rows) => rows
.filter_map(|r| r.ok())
.filter_map(|(nul, nid)| {
Some((Felt::from_hex(&nul).ok()?, Felt::from_hex(&nid).ok()?))
})
.collect(),
Err(_) => Vec::new(),
},
Err(_) => Vec::new(),
};
(notes, nullifiers)
}
fn load_private_notes_for_user(
&self,
user: &Felt,
) -> (
Vec<crate::decode::privacy_sync::DecryptedNote>,
Vec<(Felt, Felt)>,
) {
use crate::decode::privacy_sync::{DecryptedNote, NoteDirection};
let db = match self.db.get() {
Ok(db) => db,
Err(_) => return (Vec::new(), Vec::new()),
};
let user_hex = format!("{:#x}", user);
let notes: Vec<DecryptedNote> = match db.prepare(
"SELECT note_id, user, counterparty, direction, token, amount,
channel_idx, subchannel_idx, note_idx, spent, block_number
FROM private_notes WHERE user = ?1",
) {
Ok(mut stmt) => match stmt.query_map(params![user_hex], |row| {
Ok((
row.get::<_, String>(0)?,
row.get::<_, String>(1)?,
row.get::<_, String>(2)?,
row.get::<_, String>(3)?,
row.get::<_, String>(4)?,
row.get::<_, String>(5)?,
row.get::<_, i64>(6)?,
row.get::<_, i64>(7)?,
row.get::<_, i64>(8)?,
row.get::<_, i64>(9)?,
row.get::<_, i64>(10)?,
))
}) {
Ok(rows) => rows
.filter_map(|r| r.ok())
.filter_map(|(nid, u, cp, dir, tok, amt, ch, sch, ni, sp, bn)| {
let direction = match dir.as_str() {
"incoming" => NoteDirection::Incoming,
"outgoing" => NoteDirection::Outgoing,
_ => return None,
};
Some(DecryptedNote {
note_id: Felt::from_hex(&nid).ok()?,
user: Felt::from_hex(&u).ok()?,
counterparty: Felt::from_hex(&cp).ok()?,
direction,
token: Felt::from_hex(&tok).ok()?,
amount: amt.parse::<u128>().ok()?,
channel_idx: ch.max(0) as u64,
subchannel_idx: sch.max(0) as u64,
note_idx: ni.max(0) as u64,
spent: sp != 0,
block_number: bn.max(0) as u64,
})
})
.collect(),
Err(_) => Vec::new(),
},
Err(_) => Vec::new(),
};
let nullifiers: Vec<(Felt, Felt)> =
match db.prepare("SELECT nullifier, note_id FROM private_nullifiers WHERE user = ?1") {
Ok(mut stmt) => match stmt.query_map(params![user_hex], |row| {
Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
}) {
Ok(rows) => rows
.filter_map(|r| r.ok())
.filter_map(|(nul, nid)| {
Some((Felt::from_hex(&nul).ok()?, Felt::from_hex(&nid).ok()?))
})
.collect(),
Err(_) => Vec::new(),
},
Err(_) => Vec::new(),
};
(notes, nullifiers)
}
fn save_private_notes_for_user(
&self,
user: &Felt,
notes: &[crate::decode::privacy_sync::DecryptedNote],
nullifiers: &[(Felt, Felt)],
last_synced_block: u64,
) {
use crate::decode::privacy_sync::NoteDirection;
let mut db = match self.db.get() {
Ok(db) => db,
Err(e) => {
warn!(error = %e, "save_private_notes_for_user: failed to get db connection");
return;
}
};
let user_hex = format!("{:#x}", user);
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.unwrap_or(0);
let last_block_i64 = last_synced_block.min(i64::MAX as u64) as i64;
let tx = match db.transaction_with_behavior(TransactionBehavior::Immediate) {
Ok(t) => t,
Err(e) => {
warn!(error = %e, "save_private_notes_for_user: begin tx failed");
return;
}
};
if let Err(e) = tx.execute(
"DELETE FROM private_notes WHERE user = ?1",
params![user_hex],
) {
warn!(error = %e, "save_private_notes_for_user: delete notes failed");
return;
}
if let Err(e) = tx.execute(
"DELETE FROM private_nullifiers WHERE user = ?1",
params![user_hex],
) {
warn!(error = %e, "save_private_notes_for_user: delete nullifiers failed");
return;
}
for n in notes {
let dir = match n.direction {
NoteDirection::Incoming => "incoming",
NoteDirection::Outgoing => "outgoing",
};
if let Err(e) = tx.execute(
"INSERT OR REPLACE INTO private_notes
(note_id, user, counterparty, direction, token, amount,
channel_idx, subchannel_idx, note_idx, spent, block_number)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)",
params![
format!("{:#x}", n.note_id),
format!("{:#x}", n.user),
format!("{:#x}", n.counterparty),
dir,
format!("{:#x}", n.token),
n.amount.to_string(),
n.channel_idx.min(i64::MAX as u64) as i64,
n.subchannel_idx.min(i64::MAX as u64) as i64,
n.note_idx.min(i64::MAX as u64) as i64,
if n.spent { 1_i64 } else { 0_i64 },
n.block_number.min(i64::MAX as u64) as i64,
],
) {
warn!(error = %e, "save_private_notes_for_user: insert note failed");
return;
}
}
for (nul, nid) in nullifiers {
if let Err(e) = tx.execute(
"INSERT OR REPLACE INTO private_nullifiers
(nullifier, note_id, user)
VALUES (?1, ?2, ?3)",
params![format!("{:#x}", nul), format!("{:#x}", nid), user_hex],
) {
warn!(error = %e, "save_private_notes_for_user: insert nullifier failed");
return;
}
}
if let Err(e) = tx.execute(
"INSERT OR REPLACE INTO private_notes_sync
(user, last_synced_block, synced_at)
VALUES (?1, ?2, ?3)",
params![user_hex, last_block_i64, now],
) {
warn!(error = %e, "save_private_notes_for_user: upsert sync row failed");
return;
}
if let Err(e) = tx.commit() {
warn!(error = %e, "save_private_notes_for_user: commit failed");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::data::DataSource;
use starknet::core::types::{ContractClass, TransactionTrace};
struct NullUpstream;
#[async_trait]
impl DataSource for NullUpstream {
async fn get_latest_block_number(&self) -> Result<u64> {
unimplemented!()
}
async fn get_block(&self, _number: u64) -> Result<SnBlock> {
unimplemented!()
}
async fn get_block_by_hash(&self, _hash: Felt) -> Result<u64> {
unimplemented!()
}
async fn get_block_with_txs(&self, _number: u64) -> Result<(SnBlock, Vec<SnTransaction>)> {
unimplemented!()
}
async fn get_transaction(&self, _hash: Felt) -> Result<SnTransaction> {
unimplemented!()
}
async fn get_receipt(&self, _hash: Felt) -> Result<SnReceipt> {
unimplemented!()
}
async fn get_nonce(&self, _address: Felt) -> Result<Felt> {
unimplemented!()
}
async fn get_class_hash(&self, _address: Felt) -> Result<Felt> {
unimplemented!()
}
async fn get_class(&self, _class_hash: Felt) -> Result<ContractClass> {
unimplemented!()
}
async fn get_trace(&self, _hash: Felt) -> Result<TransactionTrace> {
unimplemented!()
}
async fn get_recent_blocks(&self, _count: usize) -> Result<Vec<SnBlock>> {
unimplemented!()
}
async fn get_events_for_address(
&self,
_address: Felt,
_from_block: Option<u64>,
_to_block: Option<u64>,
_limit: usize,
) -> Result<Vec<SnEvent>> {
unimplemented!()
}
async fn call_contract(
&self,
_contract_address: Felt,
_selector: Felt,
_calldata: Vec<Felt>,
) -> Result<Vec<Felt>> {
unimplemented!()
}
}
fn new_cache() -> (CachingDataSource, tempfile::TempDir) {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cache.db");
let ds = CachingDataSource::new(Arc::new(NullUpstream), &path).expect("open cache");
(ds, dir)
}
#[test]
fn activity_total_roundtrip() {
let (ds, _d) = new_cache();
let addr = Felt::from_hex("0x1234").unwrap();
assert_eq!(ds.load_activity_total(&addr), None);
ds.save_activity_total(&addr, 11400);
assert_eq!(ds.load_activity_total(&addr), Some(11400));
ds.save_activity_total(&addr, 11450);
assert_eq!(ds.load_activity_total(&addr), Some(11450));
}
#[test]
fn save_search_progress_preserves_total_known() {
let (ds, _d) = new_cache();
let addr = Felt::from_hex("0xabcd").unwrap();
ds.save_activity_total(&addr, 11400);
ds.save_search_progress(&addr, FilterKind::Unkeyed, 3_000_000, 8_900_000);
assert_eq!(ds.load_activity_total(&addr), Some(11400));
ds.save_search_progress(&addr, FilterKind::Unkeyed, 3_000_000, 8_941_000);
assert_eq!(ds.load_activity_total(&addr), Some(11400));
assert_eq!(
ds.load_search_progress(&addr, FilterKind::Unkeyed),
Some((3_000_000, 8_941_000))
);
}
#[test]
fn call_scanned_ranges_persist_and_coalesce() {
let (ds, _d) = new_cache();
let addr = Felt::from_hex("0xca115").unwrap();
assert!(ds.load_call_scanned_ranges(&addr).is_empty());
ds.add_call_scanned_range(&addr, 1_000_000, 1_100_000);
assert_eq!(
ds.load_call_scanned_ranges(&addr),
vec![(1_000_000, 1_100_000)]
);
ds.add_call_scanned_range(&addr, 1_050_000, 1_200_000);
assert_eq!(
ds.load_call_scanned_ranges(&addr),
vec![(1_000_000, 1_200_000)]
);
ds.add_call_scanned_range(&addr, 2_000_000, 2_100_000);
assert_eq!(
ds.load_call_scanned_ranges(&addr),
vec![(1_000_000, 1_200_000), (2_000_000, 2_100_000)]
);
let other = Felt::from_hex("0xbeef").unwrap();
assert!(ds.load_call_scanned_ranges(&other).is_empty());
}
#[test]
fn search_progress_merges_ranges() {
let (ds, _d) = new_cache();
let addr = Felt::from_hex("0xbeef").unwrap();
ds.save_search_progress(&addr, FilterKind::Unkeyed, 100, 200);
ds.save_search_progress(&addr, FilterKind::Unkeyed, 50, 150);
assert_eq!(
ds.load_search_progress(&addr, FilterKind::Unkeyed),
Some((50, 200))
);
ds.save_search_progress(&addr, FilterKind::Unkeyed, 300, 400);
assert_eq!(
ds.load_search_progress(&addr, FilterKind::Unkeyed),
Some((50, 400))
);
}
#[test]
fn search_progress_split_by_filter_kind() {
let (ds, _d) = new_cache();
let addr = Felt::from_hex("0xface").unwrap();
ds.save_search_progress(&addr, FilterKind::Keyed, 1_000_000, 9_000_000);
assert_eq!(
ds.load_search_progress(&addr, FilterKind::Keyed),
Some((1_000_000, 9_000_000))
);
assert_eq!(ds.load_search_progress(&addr, FilterKind::Unkeyed), None);
ds.save_search_progress(&addr, FilterKind::Unkeyed, 8_000_000, 9_000_000);
assert_eq!(
ds.load_search_progress(&addr, FilterKind::Unkeyed),
Some((8_000_000, 9_000_000))
);
assert_eq!(
ds.load_search_progress(&addr, FilterKind::Keyed),
Some((1_000_000, 9_000_000))
);
}
#[test]
fn merge_events_dedup_drops_duplicates_preserves_fresh_first_order() {
fn ev(tx: u64, block: u64, idx: u64) -> SnEvent {
SnEvent {
from_address: Felt::ZERO,
keys: Vec::new(),
data: Vec::new(),
transaction_hash: Felt::from(tx),
block_number: block,
event_index: idx,
}
}
let fresh = vec![ev(1, 100, 0), ev(2, 101, 0)];
let cached = vec![ev(1, 100, 0), ev(3, 99, 0)];
let merged = CachingDataSource::merge_events_dedup(fresh, cached);
let keys: Vec<_> = merged
.iter()
.map(|e| (e.transaction_hash, e.block_number, e.event_index))
.collect();
assert_eq!(
keys,
vec![
(Felt::from(1u64), 100, 0),
(Felt::from(2u64), 101, 0),
(Felt::from(3u64), 99, 0),
]
);
let fresh = vec![ev(1, 100, 0), ev(1, 100, 0), ev(2, 101, 0)];
let merged = CachingDataSource::merge_events_dedup(fresh, vec![]);
assert_eq!(merged.len(), 2);
}
fn call_row(hash: u64, block: u64, name: &str) -> ContractCallSummary {
ContractCallSummary {
tx_hash: Felt::from(hash),
sender: Felt::from(0xABC_u64),
function_name: name.into(),
block_number: block,
timestamp: 0,
total_fee_fri: 0,
status: "OK".into(),
nonce: None,
tip: 0,
inner_targets: Vec::new(),
}
}
#[test]
fn address_calls_rekey_migration_and_upsert() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cache.db");
let addr = Felt::from(0x49d_u64);
let addr_hex = format!("{:#x}", addr);
{
let db = rusqlite::Connection::open(&path).unwrap();
db.execute_batch(
"CREATE TABLE address_calls (
address TEXT NOT NULL, call_index INTEGER NOT NULL, data TEXT NOT NULL,
PRIMARY KEY (address, call_index));",
)
.unwrap();
let old = [
call_row(1, 500, "a"),
call_row(2, 900, "b"),
call_row(3, 700, "c"),
];
for (i, c) in old.iter().enumerate() {
db.execute(
"INSERT INTO address_calls VALUES (?1, ?2, ?3)",
params![&addr_hex, i as i64, serde_json::to_string(c).unwrap()],
)
.unwrap();
}
db.execute(
"INSERT INTO address_calls VALUES ('0x1', 0, 'not json')",
[],
)
.unwrap();
}
let ds = CachingDataSource::new(Arc::new(NullUpstream), &path).expect("open + migrate");
let blocks: Vec<u64> = ds
.load_cached_address_calls(&addr)
.iter()
.map(|c| c.block_number)
.collect();
assert_eq!(blocks, vec![900, 700, 500]);
assert!(ds.load_cached_address_calls(&Felt::from(1_u64)).is_empty());
ds.save_address_calls(&addr, &[call_row(1, 500, "a, x"), call_row(4, 100, "d")]);
let after = ds.load_cached_address_calls(&addr);
let name = |h: u64| {
after
.iter()
.find(|c| c.tx_hash == Felt::from(h))
.map(|c| c.function_name.clone())
};
assert_eq!(after.len(), 4);
assert_eq!(name(1).as_deref(), Some("a, x"));
assert_eq!(name(2).as_deref(), Some("b"));
assert_eq!(name(4).as_deref(), Some("d"));
}
fn event(tx: u64, block: u64, idx: u64) -> SnEvent {
SnEvent {
from_address: Felt::from(0x10_u64),
keys: vec![Felt::from(idx)],
data: Vec::new(),
transaction_hash: Felt::from(tx),
block_number: block,
event_index: idx,
}
}
fn event_ids(events: &[SnEvent]) -> Vec<(u64, u64, u64)> {
events
.iter()
.map(|e| {
(
e.block_number,
crate::utils::felt_to_u64(&e.transaction_hash),
e.event_index,
)
})
.collect()
}
#[test]
fn merge_address_events_upserts_newest_first() {
let (ds, _d) = new_cache();
let addr = Felt::from(0x49d_u64);
ds.merge_address_events(&addr, &[event(1, 100, 0), event(2, 300, 0)]);
let merged = ds.merge_address_events(&addr, &[event(2, 300, 0), event(3, 200, 1)]);
assert_eq!(
event_ids(&merged),
vec![(300, 2, 0), (200, 3, 1), (100, 1, 0)]
);
ds.merge_address_events(&addr, &[event(3, 200, 0)]);
assert_eq!(ds.load_address_events(&addr).len(), 4);
}
#[test]
fn address_events_rekey_migration() {
let dir = tempfile::tempdir().expect("tempdir");
let path = dir.path().join("cache.db");
let addr = Felt::from(0x49d_u64);
let addr_hex = format!("{:#x}", addr);
{
let db = rusqlite::Connection::open(&path).unwrap();
db.execute_batch(
"CREATE TABLE address_events (
address TEXT NOT NULL, event_index INTEGER NOT NULL, data TEXT NOT NULL,
PRIMARY KEY (address, event_index));",
)
.unwrap();
for (i, e) in [event(1, 900, 1), event(1, 900, 0), event(2, 500, 0)]
.iter()
.enumerate()
{
db.execute(
"INSERT INTO address_events VALUES (?1, ?2, ?3)",
params![&addr_hex, i as i64, serde_json::to_string(e).unwrap()],
)
.unwrap();
}
db.execute(
"INSERT INTO address_events VALUES ('0x1', 0, 'not json')",
[],
)
.unwrap();
}
let ds = CachingDataSource::new(Arc::new(NullUpstream), &path).expect("open + migrate");
assert_eq!(
event_ids(&ds.load_address_events(&addr)),
vec![(900, 1, 1), (900, 1, 0), (500, 2, 0)]
);
assert!(ds.load_address_events(&Felt::from(1_u64)).is_empty());
}
#[test]
#[ignore]
fn external_cache_migration_smoke() {
let path = std::env::var("STARKTOP_TEST_CACHE_DB")
.expect("set STARKTOP_TEST_CACHE_DB to a snapshot path");
let p = std::path::PathBuf::from(path);
let _ds = CachingDataSource::new(Arc::new(NullUpstream), &p).expect("open + migrate");
}
#[test]
fn private_notes_roundtrip() {
use crate::decode::privacy_sync::{DecryptedNote, NoteDirection};
let (ds, _d) = new_cache();
let user_a = Felt::from_hex("0xa11ce").unwrap();
let user_b = Felt::from_hex("0xb0b").unwrap();
let token_usdc = Felt::from_hex("0x53c9151").unwrap();
let cp1 = Felt::from_hex("0xc1").unwrap();
let cp2 = Felt::from_hex("0xc2").unwrap();
let big_amount: u128 = (u64::MAX as u128) + 7;
let notes = vec![
DecryptedNote {
note_id: Felt::from_hex("0x111").unwrap(),
user: user_a,
counterparty: cp1,
direction: NoteDirection::Incoming,
token: token_usdc,
amount: 400_000,
channel_idx: 0,
subchannel_idx: 0,
note_idx: 0,
spent: false,
block_number: 1_234_567,
},
DecryptedNote {
note_id: Felt::from_hex("0x222").unwrap(),
user: user_a,
counterparty: cp2,
direction: NoteDirection::Outgoing,
token: token_usdc,
amount: big_amount,
channel_idx: 1,
subchannel_idx: 2,
note_idx: 3,
spent: false,
block_number: 1_234_700,
},
];
let nullifiers = vec![(
Felt::from_hex("0xdead").unwrap(),
Felt::from_hex("0x111").unwrap(),
)];
ds.save_private_notes_for_user(&user_a, ¬es, &nullifiers, 1_234_700);
let (loaded_notes, loaded_nullifiers) = ds.load_private_notes();
assert_eq!(loaded_notes.len(), 2);
assert_eq!(loaded_nullifiers.len(), 1);
let n0 = loaded_notes
.iter()
.find(|n| n.note_id == Felt::from_hex("0x111").unwrap())
.expect("note 0x111");
assert_eq!(n0.user, user_a);
assert_eq!(n0.counterparty, cp1);
assert_eq!(n0.direction, NoteDirection::Incoming);
assert_eq!(n0.token, token_usdc);
assert_eq!(n0.amount, 400_000);
assert!(!n0.spent);
assert_eq!(n0.block_number, 1_234_567);
let n1 = loaded_notes
.iter()
.find(|n| n.note_id == Felt::from_hex("0x222").unwrap())
.expect("note 0x222");
assert_eq!(n1.direction, NoteDirection::Outgoing);
assert_eq!(n1.amount, big_amount);
assert_eq!(n1.channel_idx, 1);
assert_eq!(n1.subchannel_idx, 2);
assert_eq!(n1.note_idx, 3);
assert_eq!(
loaded_nullifiers[0],
(
Felt::from_hex("0xdead").unwrap(),
Felt::from_hex("0x111").unwrap(),
)
);
let notes_b = vec![DecryptedNote {
note_id: Felt::from_hex("0x333").unwrap(),
user: user_b,
counterparty: cp1,
direction: NoteDirection::Incoming,
token: token_usdc,
amount: 1,
channel_idx: 0,
subchannel_idx: 0,
note_idx: 0,
spent: true,
block_number: 1_234_800,
}];
ds.save_private_notes_for_user(&user_b, ¬es_b, &[], 1_234_800);
let notes_a2 = vec![DecryptedNote {
note_id: Felt::from_hex("0x999").unwrap(),
user: user_a,
counterparty: cp1,
direction: NoteDirection::Incoming,
token: token_usdc,
amount: 5,
channel_idx: 0,
subchannel_idx: 0,
note_idx: 0,
spent: false,
block_number: 1_234_900,
}];
ds.save_private_notes_for_user(&user_a, ¬es_a2, &[], 1_234_900);
let (loaded2, loaded_nuls2) = ds.load_private_notes();
let ids: std::collections::HashSet<Felt> = loaded2.iter().map(|n| n.note_id).collect();
assert!(ids.contains(&Felt::from_hex("0x999").unwrap()));
assert!(ids.contains(&Felt::from_hex("0x333").unwrap()));
assert!(!ids.contains(&Felt::from_hex("0x111").unwrap()));
assert!(!ids.contains(&Felt::from_hex("0x222").unwrap()));
assert!(loaded_nuls2.is_empty());
}
}