Mirror/brk
1
0
Fork 0
mirror of https://github.com/bitcoinresearchkit/brk.git synced 2026-04-25 07:09:59 -07:00
Code Issues Packages Projects Releases Wiki Activity

global: address -> addr rename

Browse Source
This commit is contained in:
nym21
2026-03-17 11:01:21 +01:00
parent 5609e6c010
commit f62943199c
141 changed files with 3788 additions and 3754 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
crates/brk_query/src/impl/address.rs → crates/brk_query/src/impl/addr.rs
View File

@@ -3,9 +3,9 @@ use std::str::FromStr;
use bitcoin::{Network, PublicKey, ScriptBuf};
use brk_error::{Error, Result};
use brk_types::{
Address, AddressBytes, AddressChainStats, AddressHash, AddressIndexOutPoint,
AddressIndexTxIndex, AddressStats, AnyAddressDataIndexEnum, OutputType, Sats, Transaction,
TxIndex, TxStatus, Txid, TypeIndex, Unit, Utxo, Vout,
Addr, AddrBytes, AddrChainStats, AddrHash, AddrIndexOutPoint, AddrIndexTxIndex, AddrStats,
AnyAddrDataIndexEnum, OutputType, Sats, Transaction, TxIndex, TxStatus, Txid, TypeIndex, Unit,
Utxo, Vout,
};
use vecdb::{ReadableVec, VecIndex};
@@ -15,73 +15,73 @@ use crate::Query;
const MAX_MEMPOOL_TXIDS: usize = 50;
impl Query {
pub fn address(&self, address: Address) -> Result<AddressStats> {
pub fn addr(&self, addr: Addr) -> Result<AddrStats> {
let indexer = self.indexer();
let computer = self.computer();
let stores = &indexer.stores;
let script = if let Ok(address) = bitcoin::Address::from_str(&address) {
if !address.is_valid_for_network(Network::Bitcoin) {
let script = if let Ok(addr) = bitcoin::Address::from_str(&addr) {
if !addr.is_valid_for_network(Network::Bitcoin) {
return Err(Error::InvalidNetwork);
}
let address = address.assume_checked();
address.script_pubkey()
} else if let Ok(pubkey) = PublicKey::from_str(&address) {
let addr = addr.assume_checked();
addr.script_pubkey()
} else if let Ok(pubkey) = PublicKey::from_str(&addr) {
ScriptBuf::new_p2pk(&pubkey)
} else {
return Err(Error::InvalidAddress);
return Err(Error::InvalidAddr);
};
let output_type = OutputType::from(&script);
let Ok(bytes) = AddressBytes::try_from((&script, output_type)) else {
return Err(Error::InvalidAddress);
let Ok(bytes) = AddrBytes::try_from((&script, output_type)) else {
return Err(Error::InvalidAddr);
};
let address_type = output_type;
let hash = AddressHash::from(&bytes);
let addr_type = output_type;
let hash = AddrHash::from(&bytes);
let Ok(Some(type_index)) = stores
.address_type_to_address_hash_to_address_index
.get_unwrap(address_type)
.addr_type_to_addr_hash_to_addr_index
.get_unwrap(addr_type)
.get(&hash)
.map(|opt| opt.map(|cow| cow.into_owned()))
else {
return Err(Error::UnknownAddress);
return Err(Error::UnknownAddr);
};
let any_address_index = computer
let any_addr_index = computer
.distribution
.any_address_indexes
.any_addr_indexes
.get_once(output_type, type_index)?;
let address_data = match any_address_index.to_enum() {
AnyAddressDataIndexEnum::Funded(index) => computer
let addr_data = match any_addr_index.to_enum() {
AnyAddrDataIndexEnum::Funded(index) => computer
.distribution
.addresses_data
.addrs_data
.funded
.reader()
.get(usize::from(index)),
AnyAddressDataIndexEnum::Empty(index) => computer
AnyAddrDataIndexEnum::Empty(index) => computer
.distribution
.addresses_data
.addrs_data
.empty
.reader()
.get(usize::from(index))
.into(),
};
Ok(AddressStats {
address,
chain_stats: AddressChainStats {
Ok(AddrStats {
addr,
chain_stats: AddrChainStats {
type_index,
funded_txo_count: address_data.funded_txo_count,
funded_txo_sum: address_data.received,
spent_txo_count: address_data.spent_txo_count,
spent_txo_sum: address_data.sent,
tx_count: address_data.tx_count,
funded_txo_count: addr_data.funded_txo_count,
funded_txo_sum: addr_data.received,
spent_txo_count: addr_data.spent_txo_count,
spent_txo_sum: addr_data.sent,
tx_count: addr_data.tx_count,
},
mempool_stats: self.mempool().map(|mempool| {
mempool
.get_addresses()
.get_addrs()
.get(&bytes)
.map(|(stats, _)| stats)
.cloned()
@@ -90,26 +90,26 @@ impl Query {
})
}
pub fn address_txs(
pub fn addr_txs(
&self,
address: Address,
addr: Addr,
after_txid: Option<Txid>,
limit: usize,
) -> Result<Vec<Transaction>> {
let txindices = self.address_txindices(&address, after_txid, limit)?;
let txindices = self.addr_txindices(&addr, after_txid, limit)?;
txindices
.into_iter()
.map(|tx_index| self.transaction_by_index(tx_index))
.collect()
}
pub fn address_txids(
pub fn addr_txids(
&self,
address: Address,
addr: Addr,
after_txid: Option<Txid>,
limit: usize,
) -> Result<Vec<Txid>> {
let txindices = self.address_txindices(&address, after_txid, limit)?;
let txindices = self.addr_txindices(&addr, after_txid, limit)?;
let txid_reader = self.indexer().vecs.transactions.txid.reader();
let txids = txindices
.into_iter()
@@ -118,19 +118,19 @@ impl Query {
Ok(txids)
}
fn address_txindices(
fn addr_txindices(
&self,
address: &Address,
addr: &Addr,
after_txid: Option<Txid>,
limit: usize,
) -> Result<Vec<TxIndex>> {
let indexer = self.indexer();
let stores = &indexer.stores;
let (output_type, type_index) = self.resolve_address(address)?;
let (output_type, type_index) = self.resolve_addr(addr)?;
let store = stores
.address_type_to_address_index_and_tx_index
.addr_type_to_addr_index_and_tx_index
.get(output_type)
.unwrap();
@@ -151,7 +151,7 @@ impl Query {
Ok(store
.prefix(prefix)
.rev()
.filter(|(key, _): &(AddressIndexTxIndex, Unit)| {
.filter(|(key, _): &(AddrIndexTxIndex, Unit)| {
if let Some(after) = after_tx_index {
key.tx_index() < after
} else {
@@ -163,15 +163,15 @@ impl Query {
.collect())
}
pub fn address_utxos(&self, address: Address) -> Result<Vec<Utxo>> {
pub fn addr_utxos(&self, addr: Addr) -> Result<Vec<Utxo>> {
let indexer = self.indexer();
let stores = &indexer.stores;
let vecs = &indexer.vecs;
let (output_type, type_index) = self.resolve_address(&address)?;
let (output_type, type_index) = self.resolve_addr(&addr)?;
let store = stores
.address_type_to_address_index_and_unspent_outpoint
.addr_type_to_addr_index_and_unspent_outpoint
.get(output_type)
.unwrap();
@@ -179,7 +179,7 @@ impl Query {
let outpoints: Vec<(TxIndex, Vout)> = store
.prefix(prefix)
.map(|(key, _): (AddressIndexOutPoint, Unit)| (key.tx_index(), key.vout()))
.map(|(key, _): (AddrIndexOutPoint, Unit)| (key.tx_index(), key.vout()))
.collect();
let txid_reader = vecs.transactions.txid.reader();
@@ -223,23 +223,23 @@ impl Query {
Ok(utxos)
}
pub fn address_mempool_hash(&self, address: &Address) -> u64 {
pub fn addr_mempool_hash(&self, addr: &Addr) -> u64 {
let Some(mempool) = self.mempool() else {
return 0;
};
let Ok(bytes) = AddressBytes::from_str(address) else {
let Ok(bytes) = AddrBytes::from_str(addr) else {
return 0;
};
mempool.address_hash(&bytes)
mempool.addr_hash(&bytes)
}
pub fn address_mempool_txids(&self, address: Address) -> Result<Vec<Txid>> {
pub fn addr_mempool_txids(&self, addr: Addr) -> Result<Vec<Txid>> {
let mempool = self.mempool().ok_or(Error::MempoolNotAvailable)?;
let bytes = AddressBytes::from_str(&address)?;
let addresses = mempool.get_addresses();
let bytes = AddrBytes::from_str(&addr)?;
let addrs = mempool.get_addrs();
let txids: Vec<Txid> = addresses
let txids: Vec<Txid> = addrs
.get(&bytes)
.map(|(_, txids)| txids.iter().take(MAX_MEMPOOL_TXIDS).cloned().collect())
.unwrap_or_default();
@@ -248,21 +248,21 @@ impl Query {
}
/// Resolve an address string to its output type and type_index
fn resolve_address(&self, address: &Address) -> Result<(OutputType, TypeIndex)> {
fn resolve_addr(&self, addr: &Addr) -> Result<(OutputType, TypeIndex)> {
let stores = &self.indexer().stores;
let bytes = AddressBytes::from_str(address)?;
let bytes = AddrBytes::from_str(addr)?;
let output_type = OutputType::from(&bytes);
let hash = AddressHash::from(&bytes);
let hash = AddrHash::from(&bytes);
let Ok(Some(type_index)) = stores
.address_type_to_address_hash_to_address_index
.addr_type_to_addr_hash_to_addr_index
.get(output_type)
.unwrap()
.get(&hash)
.map(|opt| opt.map(|cow| cow.into_owned()))
else {
return Err(Error::UnknownAddress);
return Err(Error::UnknownAddr);
};
Ok((output_type, type_index))

6
crates/brk_query/src/impl/mod.rs
View File

@@ -1,11 +1,11 @@
mod address;
mod addr;
mod block;
mod cost_basis;
mod mempool;
mod series;
mod mining;
mod price;
mod transaction;
mod series;
mod tx;
pub use block::BLOCK_TXS_PAGE_SIZE;
pub use series::ResolvedQuery;

4
crates/brk_query/src/impl/transaction.rs → crates/brk_query/src/impl/tx.rs
View File

@@ -244,7 +244,7 @@ impl Query {
let value_reader = indexer.vecs.outputs.value.reader();
let output_type_reader = indexer.vecs.outputs.output_type.reader();
let type_index_reader = indexer.vecs.outputs.type_index.reader();
let address_readers = indexer.vecs.addresses.address_readers();
let addr_readers = indexer.vecs.addrs.addr_readers();
// Batch-read outpoints for all inputs (avoids per-input PcoVec page decompression)
let outpoints: Vec<_> = indexer.vecs.inputs.outpoint.collect_range_at(
@@ -280,7 +280,7 @@ impl Query {
output_type_reader.get(usize::from(prev_txout_index));
let prev_type_index = type_index_reader.get(usize::from(prev_txout_index));
let script_pubkey =
address_readers.script_pubkey(prev_output_type, prev_type_index);
addr_readers.script_pubkey(prev_output_type, prev_type_index);
let prevout = Some(TxOut::from((script_pubkey, prev_value)));