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

global: renames part 2

Browse Source
This commit is contained in:
nym21
2026-03-13 22:42:43 +01:00
parent 0795c1bbf8
commit a0d378d06d
117 changed files with 3024 additions and 3189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
crates/brk_query/src/impl/address.rs
View File

@@ -32,16 +32,16 @@ impl Query {
return Err(Error::InvalidAddress);
};
let outputtype = OutputType::from(&script);
let Ok(bytes) = AddressBytes::try_from((&script, outputtype)) else {
let output_type = OutputType::from(&script);
let Ok(bytes) = AddressBytes::try_from((&script, output_type)) else {
return Err(Error::InvalidAddress);
};
let addresstype = outputtype;
let address_type = output_type;
let hash = AddressHash::from(&bytes);
let Ok(Some(type_index)) = stores
.addresstype_to_addresshash_to_addressindex
.get_unwrap(addresstype)
.address_type_to_address_hash_to_address_index
.get_unwrap(address_type)
.get(&hash)
.map(|opt| opt.map(|cow| cow.into_owned()))
else {
@@ -51,7 +51,7 @@ impl Query {
let any_address_index = computer
.distribution
.any_address_indexes
.get_once(outputtype, type_index)?;
.get_once(output_type, type_index)?;
let address_data = match any_address_index.to_enum() {
AnyAddressDataIndexEnum::Funded(index) => computer
@@ -99,7 +99,7 @@ impl Query {
let txindices = self.address_txindices(&address, after_txid, limit)?;
txindices
.into_iter()
.map(|txindex| self.transaction_by_index(txindex))
.map(|tx_index| self.transaction_by_index(tx_index))
.collect()
}
@@ -113,7 +113,7 @@ impl Query {
let txid_reader = self.indexer().vecs.transactions.txid.reader();
let txids = txindices
.into_iter()
.map(|txindex| txid_reader.get(txindex.to_usize()))
.map(|tx_index| txid_reader.get(tx_index.to_usize()))
.collect();
Ok(txids)
}
@@ -127,23 +127,23 @@ impl Query {
let indexer = self.indexer();
let stores = &indexer.stores;
let (outputtype, type_index) = self.resolve_address(address)?;
let (output_type, type_index) = self.resolve_address(address)?;
let store = stores
.addresstype_to_addressindex_and_txindex
.get(outputtype)
.address_type_to_address_index_and_tx_index
.get(output_type)
.unwrap();
let prefix = u32::from(type_index).to_be_bytes();
let after_txindex = if let Some(after_txid) = after_txid {
let txindex = stores
.txidprefix_to_txindex
let after_tx_index = if let Some(after_txid) = after_txid {
let tx_index = stores
.txid_prefix_to_tx_index
.get(&after_txid.into())
.map_err(|_| Error::UnknownTxid)?
.ok_or(Error::UnknownTxid)?
.into_owned();
Some(txindex)
Some(tx_index)
} else {
None
};
@@ -152,14 +152,14 @@ impl Query {
.prefix(prefix)
.rev()
.filter(|(key, _): &(AddressIndexTxIndex, Unit)| {
if let Some(after) = after_txindex {
key.txindex() < after
if let Some(after) = after_tx_index {
key.tx_index() < after
} else {
true
}
})
.take(limit)
.map(|(key, _)| key.txindex())
.map(|(key, _)| key.tx_index())
.collect())
}
@@ -168,37 +168,37 @@ impl Query {
let stores = &indexer.stores;
let vecs = &indexer.vecs;
let (outputtype, type_index) = self.resolve_address(&address)?;
let (output_type, type_index) = self.resolve_address(&address)?;
let store = stores
.addresstype_to_addressindex_and_unspentoutpoint
.get(outputtype)
.address_type_to_address_index_and_unspent_outpoint
.get(output_type)
.unwrap();
let prefix = u32::from(type_index).to_be_bytes();
let outpoints: Vec<(TxIndex, Vout)> = store
.prefix(prefix)
.map(|(key, _): (AddressIndexOutPoint, Unit)| (key.txindex(), key.vout()))
.map(|(key, _): (AddressIndexOutPoint, Unit)| (key.tx_index(), key.vout()))
.collect();
let txid_reader = vecs.transactions.txid.reader();
let first_txoutindex_reader = vecs.transactions.first_txoutindex.reader();
let first_txout_index_reader = vecs.transactions.first_txout_index.reader();
let value_reader = vecs.outputs.value.reader();
let blockhash_reader = vecs.blocks.blockhash.reader();
let utxos: Vec<Utxo> = outpoints
.into_iter()
.map(|(txindex, vout)| {
let txid: Txid = txid_reader.get(txindex.to_usize());
.map(|(tx_index, vout)| {
let txid: Txid = txid_reader.get(tx_index.to_usize());
let height = vecs
.transactions
.height
.collect_one_at(txindex.to_usize())
.collect_one_at(tx_index.to_usize())
.unwrap();
let first_txoutindex = first_txoutindex_reader.get(txindex.to_usize());
let txoutindex = first_txoutindex + vout;
let value: Sats = value_reader.get(usize::from(txoutindex));
let first_txout_index = first_txout_index_reader.get(tx_index.to_usize());
let txout_index = first_txout_index + vout;
let value: Sats = value_reader.get(usize::from(txout_index));
let block_hash = blockhash_reader.get(usize::from(height));
let block_time = vecs
.blocks
@@ -252,12 +252,12 @@ impl Query {
let stores = &self.indexer().stores;
let bytes = AddressBytes::from_str(address)?;
let outputtype = OutputType::from(&bytes);
let output_type = OutputType::from(&bytes);
let hash = AddressHash::from(&bytes);
let Ok(Some(type_index)) = stores
.addresstype_to_addresshash_to_addressindex
.get(outputtype)
.address_type_to_address_hash_to_address_index
.get(output_type)
.unwrap()
.get(&hash)
.map(|opt| opt.map(|cow| cow.into_owned()))
@@ -265,6 +265,6 @@ impl Query {
return Err(Error::UnknownAddress);
};
Ok((outputtype, type_index))
Ok((output_type, type_index))
}
}

32
crates/brk_query/src/impl/block/info.rs
View File

@@ -64,28 +64,28 @@ impl Query {
let sizes = indexer.vecs.blocks.total.collect_range_at(begin, end);
let weights = indexer.vecs.blocks.weight.collect_range_at(begin, end);
// Batch-read first_txindex for tx_count computation (need one extra for next boundary)
let txindex_end = if end <= max_height.to_usize() {
// Batch-read first_tx_index for tx_count computation (need one extra for next boundary)
let tx_index_end = if end <= max_height.to_usize() {
end + 1
} else {
end
};
let first_txindexes: Vec<TxIndex> = indexer
let first_tx_indexes: Vec<TxIndex> = indexer
.vecs
.transactions
.first_txindex
.collect_range_at(begin, txindex_end);
let total_txs = computer.indexes.txindex.identity.len();
.first_tx_index
.collect_range_at(begin, tx_index_end);
let total_txs = computer.indexes.tx_index.identity.len();
let mut blocks = Vec::with_capacity(count);
for i in (0..count).rev() {
let height = Height::from(begin + i);
let blockhash = indexer.vecs.blocks.blockhash.read_once(height)?;
let tx_count = if i + 1 < first_txindexes.len() {
first_txindexes[i + 1].to_usize() - first_txindexes[i].to_usize()
let tx_count = if i + 1 < first_tx_indexes.len() {
first_tx_indexes[i + 1].to_usize() - first_tx_indexes[i].to_usize()
} else {
total_txs - first_txindexes[i].to_usize()
total_txs - first_tx_indexes[i].to_usize()
};
blocks.push(BlockInfo {
@@ -111,7 +111,7 @@ impl Query {
indexer
.stores
.blockhashprefix_to_height
.blockhash_prefix_to_height
.get(&prefix)?
.map(|h| *h)
.ok_or(Error::NotFound("Block not found".into()))
@@ -125,23 +125,23 @@ impl Query {
let indexer = self.indexer();
let computer = self.computer();
let first_txindex = indexer
let first_tx_index = indexer
.vecs
.transactions
.first_txindex
.first_tx_index
.collect_one(height)
.unwrap();
let next_first_txindex = if height < max_height {
let next_first_tx_index = if height < max_height {
indexer
.vecs
.transactions
.first_txindex
.first_tx_index
.collect_one(height.incremented())
.unwrap()
} else {
TxIndex::from(computer.indexes.txindex.identity.len())
TxIndex::from(computer.indexes.tx_index.identity.len())
};
Ok((next_first_txindex.to_usize() - first_txindex.to_usize()) as u32)
Ok((next_first_tx_index.to_usize() - first_tx_index.to_usize()) as u32)
}
}

44
crates/brk_query/src/impl/block/txs.rs
View File

@@ -31,21 +31,21 @@ impl Query {
return Err(Error::OutOfRange("Block height out of range".into()));
}
let first_txindex = indexer
let first_tx_index = indexer
.vecs
.transactions
.first_txindex
.first_tx_index
.collect_one(height)
.unwrap();
let next_first_txindex = indexer
let next_first_tx_index = indexer
.vecs
.transactions
.first_txindex
.first_tx_index
.collect_one(height.incremented())
.unwrap_or_else(|| TxIndex::from(indexer.vecs.transactions.txid.len()));
let first: usize = first_txindex.into();
let next: usize = next_first_txindex.into();
let first: usize = first_tx_index.into();
let next: usize = next_first_tx_index.into();
let txids: Vec<Txid> = indexer.vecs.transactions.txid.collect_range_at(first, next);
@@ -60,21 +60,21 @@ impl Query {
return Err(Error::OutOfRange("Block height out of range".into()));
}
let first_txindex = indexer
let first_tx_index = indexer
.vecs
.transactions
.first_txindex
.first_tx_index
.collect_one(height)
.unwrap();
let next_first_txindex = indexer
let next_first_tx_index = indexer
.vecs
.transactions
.first_txindex
.first_tx_index
.collect_one(height.incremented())
.unwrap_or_else(|| TxIndex::from(indexer.vecs.transactions.txid.len()));
let first: usize = first_txindex.into();
let next: usize = next_first_txindex.into();
let first: usize = first_tx_index.into();
let next: usize = next_first_tx_index.into();
let tx_count = next - first;
if start_index >= tx_count {
@@ -86,8 +86,8 @@ impl Query {
let mut txs = Vec::with_capacity(count);
for i in start_index..end_index {
let txindex = TxIndex::from(first + i);
let tx = self.transaction_by_index(txindex)?;
let tx_index = TxIndex::from(first + i);
let tx = self.transaction_by_index(tx_index)?;
txs.push(tx);
}
@@ -102,29 +102,29 @@ impl Query {
return Err(Error::OutOfRange("Block height out of range".into()));
}
let first_txindex = indexer
let first_tx_index = indexer
.vecs
.transactions
.first_txindex
.first_tx_index
.collect_one(height)
.unwrap();
let next_first_txindex = indexer
let next_first_tx_index = indexer
.vecs
.transactions
.first_txindex
.first_tx_index
.collect_one(height.incremented())
.unwrap_or_else(|| TxIndex::from(indexer.vecs.transactions.txid.len()));
let first: usize = first_txindex.into();
let next: usize = next_first_txindex.into();
let first: usize = first_tx_index.into();
let next: usize = next_first_tx_index.into();
let tx_count = next - first;
if index >= tx_count {
return Err(Error::OutOfRange("Transaction index out of range".into()));
}
let txindex = first + index;
let txid = indexer.vecs.transactions.txid.reader().get(txindex);
let tx_index = first + index;
let txid = indexer.vecs.transactions.txid.reader().get(tx_index);
Ok(txid)
}

4
crates/brk_query/src/impl/mining/block_fee_rates.rs
View File

@@ -1,8 +1,8 @@
// TODO: INCOMPLETE - indexes_to_fee_rate.day1 doesn't have percentile fields
// because from_txindex.rs calls remove_percentiles() before creating day1.
// because from_tx_index.rs calls remove_percentiles() before creating day1.
// Need to either:
// 1. Use .height instead and convert height to day1 for iteration
// 2. Fix from_txindex.rs to preserve percentiles for day1
// 2. Fix from_tx_index.rs to preserve percentiles for day1
// 3. Create a separate day1 computation path with percentiles
#![allow(dead_code)]

148
crates/brk_query/src/impl/transaction.rs
View File

@@ -22,16 +22,16 @@ impl Query {
// Look up confirmed transaction by txid prefix
let prefix = TxidPrefix::from(&txid);
let indexer = self.indexer();
let Ok(Some(txindex)) = indexer
let Ok(Some(tx_index)) = indexer
.stores
.txidprefix_to_txindex
.txid_prefix_to_tx_index
.get(&prefix)
.map(|opt| opt.map(|cow| cow.into_owned()))
else {
return Err(Error::UnknownTxid);
};
self.transaction_by_index(txindex)
self.transaction_by_index(tx_index)
}
pub fn transaction_status(&self, TxidParam { txid }: TxidParam) -> Result<TxStatus> {
@@ -45,9 +45,9 @@ impl Query {
// Look up confirmed transaction by txid prefix
let prefix = TxidPrefix::from(&txid);
let indexer = self.indexer();
let Ok(Some(txindex)) = indexer
let Ok(Some(tx_index)) = indexer
.stores
.txidprefix_to_txindex
.txid_prefix_to_tx_index
.get(&prefix)
.map(|opt| opt.map(|cow| cow.into_owned()))
else {
@@ -59,7 +59,7 @@ impl Query {
.vecs
.transactions
.height
.collect_one(txindex)
.collect_one(tx_index)
.unwrap();
let block_hash = indexer.vecs.blocks.blockhash.read_once(height)?;
let block_time = indexer.vecs.blocks.timestamp.collect_one(height).unwrap();
@@ -83,16 +83,16 @@ impl Query {
// Look up confirmed transaction by txid prefix
let prefix = TxidPrefix::from(&txid);
let indexer = self.indexer();
let Ok(Some(txindex)) = indexer
let Ok(Some(tx_index)) = indexer
.stores
.txidprefix_to_txindex
.txid_prefix_to_tx_index
.get(&prefix)
.map(|opt| opt.map(|cow| cow.into_owned()))
else {
return Err(Error::UnknownTxid);
};
self.transaction_hex_by_index(txindex)
self.transaction_hex_by_index(tx_index)
}
pub fn outspend(&self, TxidParam { txid }: TxidParam, vout: Vout) -> Result<TxOutspend> {
@@ -106,32 +106,32 @@ impl Query {
// Look up confirmed transaction
let prefix = TxidPrefix::from(&txid);
let indexer = self.indexer();
let Ok(Some(txindex)) = indexer
let Ok(Some(tx_index)) = indexer
.stores
.txidprefix_to_txindex
.txid_prefix_to_tx_index
.get(&prefix)
.map(|opt| opt.map(|cow| cow.into_owned()))
else {
return Err(Error::UnknownTxid);
};
// Calculate txoutindex
let first_txoutindex = indexer
// Calculate txout_index
let first_txout_index = indexer
.vecs
.transactions
.first_txoutindex
.read_once(txindex)?;
let txoutindex = first_txoutindex + vout;
.first_txout_index
.read_once(tx_index)?;
let txout_index = first_txout_index + vout;
// Look up spend status
let computer = self.computer();
let txinindex = computer.outputs.spent.txinindex.read_once(txoutindex)?;
let txin_index = computer.outputs.spent.txin_index.read_once(txout_index)?;
if txinindex == TxInIndex::UNSPENT {
if txin_index == TxInIndex::UNSPENT {
return Ok(TxOutspend::UNSPENT);
}
self.outspend_details(txinindex)
self.outspend_details(txin_index)
}
pub fn outspends(&self, TxidParam { txid }: TxidParam) -> Result<Vec<TxOutspend>> {
@@ -146,9 +146,9 @@ impl Query {
// Look up confirmed transaction
let prefix = TxidPrefix::from(&txid);
let indexer = self.indexer();
let Ok(Some(txindex)) = indexer
let Ok(Some(tx_index)) = indexer
.stores
.txidprefix_to_txindex
.txid_prefix_to_tx_index
.get(&prefix)
.map(|opt| opt.map(|cow| cow.into_owned()))
else {
@@ -156,31 +156,31 @@ impl Query {
};
// Get output range
let first_txoutindex = indexer
let first_txout_index = indexer
.vecs
.transactions
.first_txoutindex
.read_once(txindex)?;
let next_first_txoutindex = indexer
.first_txout_index
.read_once(tx_index)?;
let next_first_txout_index = indexer
.vecs
.transactions
.first_txoutindex
.read_once(txindex.incremented())?;
let output_count = usize::from(next_first_txoutindex) - usize::from(first_txoutindex);
.first_txout_index
.read_once(tx_index.incremented())?;
let output_count = usize::from(next_first_txout_index) - usize::from(first_txout_index);
// Get spend status for each output
let computer = self.computer();
let txinindex_reader = computer.outputs.spent.txinindex.reader();
let txin_index_reader = computer.outputs.spent.txin_index.reader();
let mut outspends = Vec::with_capacity(output_count);
for i in 0..output_count {
let txoutindex = first_txoutindex + Vout::from(i);
let txinindex = txinindex_reader.get(usize::from(txoutindex));
let txout_index = first_txout_index + Vout::from(i);
let txin_index = txin_index_reader.get(usize::from(txout_index));
if txinindex == TxInIndex::UNSPENT {
if txin_index == TxInIndex::UNSPENT {
outspends.push(TxOutspend::UNSPENT);
} else {
outspends.push(self.outspend_details(txinindex)?);
outspends.push(self.outspend_details(txin_index)?);
}
}
@@ -189,44 +189,44 @@ impl Query {
// === Helper methods ===
pub fn transaction_by_index(&self, txindex: TxIndex) -> Result<Transaction> {
pub fn transaction_by_index(&self, tx_index: TxIndex) -> Result<Transaction> {
let indexer = self.indexer();
let reader = self.reader();
let computer = self.computer();
// Get tx metadata using collect_one for PcoVec, read_once for BytesVec
let txid = indexer.vecs.transactions.txid.read_once(txindex)?;
let txid = indexer.vecs.transactions.txid.read_once(tx_index)?;
let height = indexer
.vecs
.transactions
.height
.collect_one(txindex)
.collect_one(tx_index)
.unwrap();
let version = indexer
.vecs
.transactions
.txversion
.collect_one(txindex)
.tx_version
.collect_one(tx_index)
.unwrap();
let lock_time = indexer
.vecs
.transactions
.rawlocktime
.collect_one(txindex)
.raw_locktime
.collect_one(tx_index)
.unwrap();
let total_size = indexer
.vecs
.transactions
.total_size
.collect_one(txindex)
.collect_one(tx_index)
.unwrap();
let first_txinindex = indexer
let first_txin_index = indexer
.vecs
.transactions
.first_txinindex
.collect_one(txindex)
.first_txin_index
.collect_one(tx_index)
.unwrap();
let position = computer.positions.tx.collect_one(txindex).unwrap();
let position = computer.positions.tx.collect_one(tx_index).unwrap();
// Get block info for status
let block_hash = indexer.vecs.blocks.blockhash.read_once(height)?;
@@ -240,16 +240,16 @@ impl Query {
// Create readers for random access lookups
let txid_reader = indexer.vecs.transactions.txid.reader();
let first_txoutindex_reader = indexer.vecs.transactions.first_txoutindex.reader();
let first_txout_index_reader = indexer.vecs.transactions.first_txout_index.reader();
let value_reader = indexer.vecs.outputs.value.reader();
let outputtype_reader = indexer.vecs.outputs.outputtype.reader();
let typeindex_reader = indexer.vecs.outputs.typeindex.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();
// Batch-read outpoints for all inputs (avoids per-input PcoVec page decompression)
let outpoints: Vec<_> = indexer.vecs.inputs.outpoint.collect_range_at(
usize::from(first_txinindex),
usize::from(first_txinindex) + tx.input.len(),
usize::from(first_txin_index),
usize::from(first_txin_index) + tx.input.len(),
);
// Build inputs with prevout information
@@ -266,21 +266,21 @@ impl Query {
let (prev_txid, prev_vout, prevout) = if is_coinbase {
(Txid::COINBASE, Vout::MAX, None)
} else {
let prev_txindex = outpoint.txindex();
let prev_tx_index = outpoint.tx_index();
let prev_vout = outpoint.vout();
let prev_txid = txid_reader.get(prev_txindex.to_usize());
let prev_txid = txid_reader.get(prev_tx_index.to_usize());
// Calculate the txoutindex for the prevout
let prev_first_txoutindex =
first_txoutindex_reader.get(prev_txindex.to_usize());
let prev_txoutindex = prev_first_txoutindex + prev_vout;
// Calculate the txout_index for the prevout
let prev_first_txout_index =
first_txout_index_reader.get(prev_tx_index.to_usize());
let prev_txout_index = prev_first_txout_index + prev_vout;
let prev_value = value_reader.get(usize::from(prev_txoutindex));
let prev_outputtype: OutputType =
outputtype_reader.get(usize::from(prev_txoutindex));
let prev_typeindex = typeindex_reader.get(usize::from(prev_txoutindex));
let prev_value = value_reader.get(usize::from(prev_txout_index));
let prev_output_type: OutputType =
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_outputtype, prev_typeindex);
address_readers.script_pubkey(prev_output_type, prev_type_index);
let prevout = Some(TxOut::from((script_pubkey, prev_value)));
@@ -318,7 +318,7 @@ impl Query {
};
let mut transaction = Transaction {
index: Some(txindex),
index: Some(tx_index),
txid,
version,
lock_time,
@@ -337,7 +337,7 @@ impl Query {
Ok(transaction)
}
fn transaction_hex_by_index(&self, txindex: TxIndex) -> Result<String> {
fn transaction_hex_by_index(&self, tx_index: TxIndex) -> Result<String> {
let indexer = self.indexer();
let reader = self.reader();
let computer = self.computer();
@@ -346,37 +346,37 @@ impl Query {
.vecs
.transactions
.total_size
.collect_one(txindex)
.collect_one(tx_index)
.unwrap();
let position = computer.positions.tx.collect_one(txindex).unwrap();
let position = computer.positions.tx.collect_one(tx_index).unwrap();
let buffer = reader.read_raw_bytes(position, *total_size as usize)?;
Ok(buffer.to_lower_hex_string())
}
fn outspend_details(&self, txinindex: TxInIndex) -> Result<TxOutspend> {
fn outspend_details(&self, txin_index: TxInIndex) -> Result<TxOutspend> {
let indexer = self.indexer();
// Look up spending txindex directly
let spending_txindex = indexer.vecs.inputs.txindex.collect_one(txinindex).unwrap();
// Look up spending tx_index directly
let spending_tx_index = indexer.vecs.inputs.tx_index.collect_one(txin_index).unwrap();
// Calculate vin
let spending_first_txinindex = indexer
let spending_first_txin_index = indexer
.vecs
.transactions
.first_txinindex
.collect_one(spending_txindex)
.first_txin_index
.collect_one(spending_tx_index)
.unwrap();
let vin = Vin::from(usize::from(txinindex) - usize::from(spending_first_txinindex));
let vin = Vin::from(usize::from(txin_index) - usize::from(spending_first_txin_index));
// Get spending tx details
let spending_txid = indexer.vecs.transactions.txid.read_once(spending_txindex)?;
let spending_txid = indexer.vecs.transactions.txid.read_once(spending_tx_index)?;
let spending_height = indexer
.vecs
.transactions
.height
.collect_one(spending_txindex)
.collect_one(spending_tx_index)
.unwrap();
let block_hash = indexer.vecs.blocks.blockhash.read_once(spending_height)?;
let block_time = indexer