pub mod cache;
pub mod pathfinder;
pub mod rpc;
pub mod token_metadata;
pub mod types;
use async_trait::async_trait;
use starknet::core::types::Felt;
use starknet::core::types::{ContractClass, TransactionTrace};
use crate::error::Result;
use types::{
AddressTxSummary, ClassContractEntry, ClassDeclareInfo, ContractCallSummary,
MetaTxIntenderSummary, SnBlock, SnEvent, SnReceipt, SnTransaction, TokenTransfer,
};
use pathfinder::ClassHashEntry;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FilterKind {
Unkeyed,
Keyed,
DuneCalls,
}
impl FilterKind {
pub fn as_str(self) -> &'static str {
match self {
FilterKind::Unkeyed => "unkeyed",
FilterKind::Keyed => "keyed",
FilterKind::DuneCalls => "dune_calls",
}
}
}
pub trait LatestBlockSource: Send + Sync {
fn latest(&self) -> Option<u64>;
}
#[async_trait]
pub trait DataSource: Send + Sync {
async fn get_latest_block_number(&self) -> Result<u64>;
async fn latest_block_hint(&self) -> Option<u64> {
match self.get_latest_block_number().await {
Ok(n) => Some(n),
Err(e) => {
tracing::debug!(error = %e, "latest_block_hint: upstream get_latest_block_number failed");
None
}
}
}
async fn get_block(&self, number: u64) -> Result<SnBlock>;
async fn get_block_by_hash(&self, hash: Felt) -> Result<u64>;
async fn get_block_with_txs(&self, number: u64) -> Result<(SnBlock, Vec<SnTransaction>)>;
async fn get_block_status(&self, number: u64) -> Result<String> {
self.get_block(number).await.map(|b| b.status)
}
async fn get_transaction(&self, hash: Felt) -> Result<SnTransaction>;
async fn get_receipt(&self, hash: Felt) -> Result<SnReceipt>;
async fn get_nonce(&self, address: Felt) -> Result<Felt>;
async fn get_class_hash(&self, address: Felt) -> Result<Felt>;
async fn get_class_hash_at(&self, address: Felt, _block: u64) -> Result<Felt> {
self.get_class_hash(address).await
}
async fn get_class(&self, class_hash: Felt) -> Result<ContractClass>;
async fn get_storage_at(
&self,
_contract: Felt,
_key: Felt,
_block: Option<u64>,
) -> Result<Felt> {
Err(crate::error::StarktopError::Provider(
"get_storage_at not implemented for this DataSource".into(),
))
}
async fn get_trace(&self, hash: Felt) -> Result<TransactionTrace>;
async fn get_recent_blocks(&self, count: usize) -> Result<Vec<SnBlock>>;
async fn get_events_for_address(
&self,
address: Felt,
from_block: Option<u64>,
to_block: Option<u64>,
limit: usize,
) -> Result<Vec<SnEvent>>;
fn load_cached_address_txs(&self, _address: &Felt) -> Vec<AddressTxSummary> {
Vec::new() }
fn save_address_txs(&self, _address: &Felt, _txs: &[AddressTxSummary]) {
}
fn load_token_metadata(&self) -> Vec<(Felt, crate::data::token_metadata::TokenMeta)> {
Vec::new()
}
fn save_token_metadata(&self, _address: &Felt, _meta: &crate::data::token_metadata::TokenMeta) {
}
fn load_private_notes(
&self,
) -> (
Vec<crate::decode::privacy_sync::DecryptedNote>,
Vec<(Felt, Felt)>,
) {
(Vec::new(), Vec::new())
}
fn save_private_notes_for_user(
&self,
_user: &Felt,
_notes: &[crate::decode::privacy_sync::DecryptedNote],
_nullifiers: &[(Felt, Felt)],
_last_synced_block: u64,
) {
}
fn load_private_notes_for_user(
&self,
_user: &Felt,
) -> (
Vec<crate::decode::privacy_sync::DecryptedNote>,
Vec<(Felt, Felt)>,
) {
(Vec::new(), Vec::new())
}
fn load_cached_address_calls(&self, _address: &Felt) -> Vec<ContractCallSummary> {
Vec::new()
}
fn save_address_calls(&self, _address: &Felt, _calls: &[ContractCallSummary]) {
}
fn load_call_scanned_ranges(&self, _address: &Felt) -> Vec<(u64, u64)> {
Vec::new()
}
fn add_call_scanned_range(&self, _address: &Felt, _lo: u64, _hi: u64) {
}
fn load_cached_transfers(&self, _address: &Felt) -> Vec<TokenTransfer> {
Vec::new()
}
fn save_transfers(&self, _address: &Felt, _rows: &[TokenTransfer]) {}
fn load_transfer_scanned_ranges(&self, _address: &Felt) -> Vec<(u64, u64)> {
Vec::new()
}
fn add_transfer_scanned_range(&self, _address: &Felt, _lo: u64, _hi: u64) {}
async fn get_transfer_events(
&self,
_address: Felt,
_from_block: u64,
_to_block: u64,
) -> Result<Vec<TokenTransfer>> {
Err(crate::error::StarktopError::Provider(
"get_transfer_events not implemented for this DataSource".into(),
))
}
fn load_cached_meta_txs(&self, _address: &Felt) -> Vec<MetaTxIntenderSummary> {
Vec::new()
}
fn save_meta_txs(&self, _address: &Felt, _txs: &[MetaTxIntenderSummary]) {
}
fn load_cached_activity_range(&self, _address: &Felt) -> Option<(u64, u64)> {
None }
fn load_cached_activity_range_with_count(&self, _address: &Felt) -> Option<(u64, u64, u64)> {
None
}
fn load_cached_activity_range_any_age(&self, _address: &Felt) -> Option<(u64, u64, u64)> {
None
}
fn save_activity_range(&self, _address: &Felt, _min_block: u64, _max_block: u64) {
}
fn save_activity_range_with_count(
&self,
_address: &Felt,
_min_block: u64,
_max_block: u64,
_event_count: u64,
) {
}
async fn get_contract_events(
&self,
address: Felt,
from_block: Option<u64>,
to_block: Option<u64>,
limit: usize,
) -> Result<Vec<SnEvent>> {
self.get_events_for_address(address, from_block, to_block, limit)
.await
}
async fn call_contract(
&self,
contract_address: Felt,
selector: Felt,
calldata: Vec<Felt>,
) -> Result<Vec<Felt>>;
async fn batch_call_contracts(
&self,
calls: Vec<(Felt, Felt, Vec<Felt>)>,
) -> Vec<Result<Vec<Felt>>> {
let mut out = Vec::with_capacity(calls.len());
for (contract, selector, calldata) in calls {
out.push(self.call_contract(contract, selector, calldata).await);
}
out
}
async fn batch_get_storage_at(
&self,
contract: Felt,
keys: &[Felt],
block: Option<u64>,
) -> Vec<Result<Felt>> {
let mut out = Vec::with_capacity(keys.len());
for k in keys {
out.push(self.get_storage_at(contract, *k, block).await);
}
out
}
fn load_cached_deploy_info(&self, _address: &Felt) -> Option<(Felt, u64, Option<Felt>)> {
None
}
fn save_deploy_info(
&self,
_address: &Felt,
_tx_hash: &Felt,
_block: u64,
_deployer: Option<&Felt>,
) {
}
fn load_cached_class_history(&self, _address: &Felt) -> Vec<ClassHashEntry> {
Vec::new()
}
fn save_class_history(&self, _address: &Felt, _entries: &[ClassHashEntry]) {}
fn load_class_history_max_block(&self, _address: &Felt) -> Option<u64> {
None
}
fn save_class_history_max_block(&self, _address: &Felt, _block: u64) {}
fn load_cached_nonce(&self, _address: &Felt) -> Option<(Felt, u64)> {
None
}
fn save_cached_nonce(&self, _address: &Felt, _nonce: &Felt, _block: u64) {}
fn load_cached_class_hash(&self, _address: &Felt) -> Option<Felt> {
None
}
fn load_search_progress(
&self,
_address: &Felt,
_filter_kind: FilterKind,
) -> Option<(u64, u64)> {
None
}
fn save_search_progress(
&self,
_address: &Felt,
_filter_kind: FilterKind,
_min_block: u64,
_max_block: u64,
) {
}
fn load_activity_total(&self, _address: &Felt) -> Option<u64> {
None
}
fn save_activity_total(&self, _address: &Felt, _total: u64) {}
fn load_address_events(&self, _address: &Felt) -> Vec<SnEvent> {
Vec::new()
}
fn merge_address_events(&self, _address: &Felt, new_events: &[SnEvent]) -> Vec<SnEvent> {
new_events.to_vec()
}
fn append_address_events(&self, _address: &Felt, _events: &[SnEvent]) {}
fn load_cached_class_declaration(&self, _class_hash: &Felt) -> Option<ClassDeclareInfo> {
None
}
fn save_class_declaration(&self, _class_hash: &Felt, _info: &ClassDeclareInfo) {}
fn load_cached_class_contracts(&self, _class_hash: &Felt) -> Option<Vec<ClassContractEntry>> {
None
}
fn save_class_contracts(&self, _class_hash: &Felt, _contracts: &[ClassContractEntry]) {}
}