zecfoundation
/
zebra
mirror of https://github.com/ZcashFoundation/zebra.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

feat(rpc): Add fields to `getblockchaininfo` RPC output (#9215) 

* Adds some of the required fields on `getblockchaininfo` output.

* Adds state request/response variants for querying disk usage

* Adds `size_on_disk`, `chain_supply`, and `monitored` fields.

* Updates snapshots

* fixes prop tests

* fixes doc lints

* Adds missing `size()` method

* Fixes lwd integration test issue by updating get_blockchain_info to fallback on default values instead of returning an error if the state is empty.

Related: Runs state queries in parallel from getblockchaininfo RPC and removes the BlockHeader query by getting the tip block time from the latest chain tip channel.

* Updates failing proptests

* fixes lint
This commit is contained in:
Arya 2025-02-12 18:20:05 -05:00 committed by GitHub
parent ece9a8ee59
commit cf653313dd
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
18 changed files with 428 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

270
zebra-rpc/src/methods.rs
View File

@ -29,14 +29,16 @@ use zebra_chain::{
subtree::NoteCommitmentSubtreeIndex,
transaction::{self, SerializedTransaction, Transaction, UnminedTx},
transparent::{self, Address},
value_balance::ValueBalance,
work::{
difficulty::{CompactDifficulty, ExpandedDifficulty},
difficulty::{CompactDifficulty, ExpandedDifficulty, ParameterDifficulty, U256},
equihash::Solution,
},
};
use zebra_consensus::ParameterCheckpoint;
use zebra_node_services::mempool;
use zebra_state::{HashOrHeight, OutputIndex, OutputLocation, TransactionLocation};
use zebra_state::{
HashOrHeight, OutputIndex, OutputLocation, ReadRequest, ReadResponse, TransactionLocation,
};
use crate::{
methods::trees::{GetSubtrees, GetTreestate, SubtreeRpcData},
@ -546,75 +548,65 @@ where
#[allow(clippy::unwrap_in_result)]
async fn get_blockchain_info(&self) -> Result<GetBlockChainInfo> {
let network = self.network.clone();
let debug_force_finished_sync = self.debug_force_finished_sync;
let mut state = self.state.clone();
let network = &self.network;
// `chain` field
let chain = network.bip70_network_name();
let (usage_info_rsp, tip_pool_values_rsp, chain_tip_difficulty) = {
use zebra_state::ReadRequest::*;
let state_call = |request| self.state.clone().oneshot(request);
tokio::join!(
state_call(UsageInfo),
state_call(TipPoolValues),
chain_tip_difficulty(network.clone(), self.state.clone())
)
};
let (tip_height, tip_hash, tip_block_time, value_balance) = match state
.ready()
.and_then(|service| service.call(zebra_state::ReadRequest::TipPoolValues))
.await
{
Ok(zebra_state::ReadResponse::TipPoolValues {
tip_height,
tip_hash,
value_balance,
}) => {
let request = zebra_state::ReadRequest::BlockHeader(tip_hash.into());
let response: zebra_state::ReadResponse = state
.ready()
.and_then(|service| service.call(request))
.await
.map_misc_error()?;
let (size_on_disk, (tip_height, tip_hash), value_balance, difficulty) = {
use zebra_state::ReadResponse::*;
if let zebra_state::ReadResponse::BlockHeader { header, .. } = response {
(tip_height, tip_hash, header.time, value_balance)
} else {
unreachable!("unmatched response to a TipPoolValues request")
}
}
_ => {
let request =
zebra_state::ReadRequest::BlockHeader(HashOrHeight::Height(Height::MIN));
let response: zebra_state::ReadResponse = state
.ready()
.and_then(|service| service.call(request))
.await
.map_misc_error()?;
let UsageInfo(size_on_disk) = usage_info_rsp.map_misc_error()? else {
unreachable!("unmatched response to a TipPoolValues request")
};
if let zebra_state::ReadResponse::BlockHeader {
header,
hash,
height,
..
} = response
{
(height, hash, header.time, ValueBalance::zero())
} else {
unreachable!("unmatched response to a BlockHeader request")
}
}
let (tip, value_balance) = match tip_pool_values_rsp {
Ok(TipPoolValues {
tip_height,
tip_hash,
value_balance,
}) => ((tip_height, tip_hash), value_balance),
Ok(_) => unreachable!("unmatched response to a TipPoolValues request"),
Err(_) => ((Height::MIN, network.genesis_hash()), Default::default()),
};
let difficulty = chain_tip_difficulty.unwrap_or_else(|_| {
(U256::from(network.target_difficulty_limit()) >> 128).as_u128() as f64
});
(size_on_disk, tip, value_balance, difficulty)
};
let now = Utc::now();
let zebra_estimated_height =
NetworkChainTipHeightEstimator::new(tip_block_time, tip_height, &network)
.estimate_height_at(now);
let (estimated_height, verification_progress) = self
.latest_chain_tip
.best_tip_height_and_block_time()
.map(|(tip_height, tip_block_time)| {
let height =
NetworkChainTipHeightEstimator::new(tip_block_time, tip_height, network)
.estimate_height_at(now);
// If we're testing the mempool, force the estimated height to be the actual tip height, otherwise,
// check if the estimated height is below Zebra's latest tip height, or if the latest tip's block time is
// later than the current time on the local clock.
let estimated_height = if tip_block_time > now
|| zebra_estimated_height < tip_height
|| debug_force_finished_sync
{
tip_height
} else {
zebra_estimated_height
};
// If we're testing the mempool, force the estimated height to be the actual tip height, otherwise,
// check if the estimated height is below Zebra's latest tip height, or if the latest tip's block time is
// later than the current time on the local clock.
let height =
if tip_block_time > now || height < tip_height || debug_force_finished_sync {
tip_height
} else {
height
};
(height, f64::from(tip_height.0) / f64::from(height.0))
})
// TODO: Add a `genesis_block_time()` method on `Network` to use here.
.unwrap_or((Height::MIN, 0.0));
// `upgrades` object
//
@ -647,29 +639,40 @@ where
(tip_height + 1).expect("valid chain tips are a lot less than Height::MAX");
let consensus = TipConsensusBranch {
chain_tip: ConsensusBranchIdHex(
NetworkUpgrade::current(&network, tip_height)
NetworkUpgrade::current(network, tip_height)
.branch_id()
.unwrap_or(ConsensusBranchId::RPC_MISSING_ID),
),
next_block: ConsensusBranchIdHex(
NetworkUpgrade::current(&network, next_block_height)
NetworkUpgrade::current(network, next_block_height)
.branch_id()
.unwrap_or(ConsensusBranchId::RPC_MISSING_ID),
),
};
let response = GetBlockChainInfo {
chain,
chain: network.bip70_network_name(),
blocks: tip_height,
best_block_hash: tip_hash,
estimated_height,
value_pools: types::ValuePoolBalance::from_value_balance(value_balance),
chain_supply: types::Balance::chain_supply(value_balance),
value_pools: types::Balance::value_pools(value_balance),
upgrades,
consensus,
headers: tip_height,
difficulty,
verification_progress,
// TODO: store work in the finalized state for each height (#7109)
chain_work: 0,
pruned: false,
size_on_disk,
// TODO: Investigate whether this needs to be implemented (it's sprout-only in zcashd)
commitments: 0,
};
Ok(response)
}
async fn get_address_balance(&self, address_strings: AddressStrings) -> Result<AddressBalance> {
let state = self.state.clone();
@ -1540,7 +1543,7 @@ impl GetInfo {
/// Response to a `getblockchaininfo` RPC request.
///
/// See the notes for the [`Rpc::get_blockchain_info` method].
#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct GetBlockChainInfo {
/// Current network name as defined in BIP70 (main, test, regtest)
chain: String,
@ -1548,6 +1551,30 @@ pub struct GetBlockChainInfo {
/// The current number of blocks processed in the server, numeric
blocks: Height,
/// The current number of headers we have validated in the best chain, that is,
/// the height of the best chain.
headers: Height,
/// The estimated network solution rate in Sol/s.
difficulty: f64,
/// The verification progress relative to the estimated network chain tip.
#[serde(rename = "verificationprogress")]
verification_progress: f64,
/// The total amount of work in the best chain, hex-encoded.
#[serde(rename = "chainwork")]
chain_work: u64,
/// Whether this node is pruned, currently always false in Zebra.
pruned: bool,
/// The estimated size of the block and undo files on disk
size_on_disk: u64,
/// The current number of note commitments in the commitment tree
commitments: u64,
/// The hash of the currently best block, in big-endian order, hex-encoded
#[serde(rename = "bestblockhash", with = "hex")]
best_block_hash: block::Hash,
@ -1558,9 +1585,13 @@ pub struct GetBlockChainInfo {
#[serde(rename = "estimatedheight")]
estimated_height: Height,
/// Chain supply balance
#[serde(rename = "chainSupply")]
chain_supply: types::Balance,
/// Value pool balances
#[serde(rename = "valuePools")]
value_pools: [types::ValuePoolBalance; 5],
value_pools: [types::Balance; 5],
/// Status of network upgrades
upgrades: IndexMap<ConsensusBranchIdHex, NetworkUpgradeInfo>,
@ -1576,35 +1607,60 @@ impl Default for GetBlockChainInfo {
blocks: Height(1),
best_block_hash: block::Hash([0; 32]),
estimated_height: Height(1),
value_pools: types::ValuePoolBalance::zero_pools(),
chain_supply: types::Balance::chain_supply(Default::default()),
value_pools: types::Balance::zero_pools(),
upgrades: IndexMap::new(),
consensus: TipConsensusBranch {
chain_tip: ConsensusBranchIdHex(ConsensusBranchId::default()),
next_block: ConsensusBranchIdHex(ConsensusBranchId::default()),
},
headers: Height(1),
difficulty: 0.0,
verification_progress: 0.0,
chain_work: 0,
pruned: false,
size_on_disk: 0,
commitments: 0,
}
}
}
impl GetBlockChainInfo {
/// Creates a new [`GetBlockChainInfo`] instance.
#[allow(clippy::too_many_arguments)]
pub fn new(
chain: String,
blocks: Height,
best_block_hash: block::Hash,
estimated_height: Height,
value_pools: [types::ValuePoolBalance; 5],
chain_supply: types::Balance,
value_pools: [types::Balance; 5],
upgrades: IndexMap<ConsensusBranchIdHex, NetworkUpgradeInfo>,
consensus: TipConsensusBranch,
headers: Height,
difficulty: f64,
verification_progress: f64,
chain_work: u64,
pruned: bool,
size_on_disk: u64,
commitments: u64,
) -> Self {
Self {
chain,
blocks,
best_block_hash,
estimated_height,
chain_supply,
value_pools,
upgrades,
consensus,
headers,
difficulty,
verification_progress,
chain_work,
pruned,
size_on_disk,
commitments,
}
}
@ -1633,7 +1689,7 @@ impl GetBlockChainInfo {
}
/// Returns the value pool balances.
pub fn value_pools(&self) -> &[types::ValuePoolBalance; 5] {
pub fn value_pools(&self) -> &[types::Balance; 5] {
&self.value_pools
}
@ -2456,3 +2512,73 @@ mod opthex {
}
}
}
/// Returns the proof-of-work difficulty as a multiple of the minimum difficulty.
pub(crate) async fn chain_tip_difficulty<State>(network: Network, mut state: State) -> Result<f64>
where
State: Service<
zebra_state::ReadRequest,
Response = zebra_state::ReadResponse,
Error = zebra_state::BoxError,
> + Clone
+ Send
+ Sync
+ 'static,
State::Future: Send,
{
let request = ReadRequest::ChainInfo;
// # TODO
// - add a separate request like BestChainNextMedianTimePast, but skipping the
// consistency check, because any block's difficulty is ok for display
// - return 1.0 for a "not enough blocks in the state" error, like `zcashd`:
// <https://github.com/zcash/zcash/blob/7b28054e8b46eb46a9589d0bdc8e29f9fa1dc82d/src/rpc/blockchain.cpp#L40-L41>
let response = state
.ready()
.and_then(|service| service.call(request))
.await
.map_err(|error| ErrorObject::owned(0, error.to_string(), None::<()>))?;
let chain_info = match response {
ReadResponse::ChainInfo(info) => info,
_ => unreachable!("unmatched response to a chain info request"),
};
// This RPC is typically used for display purposes, so it is not consensus-critical.
// But it uses the difficulty consensus rules for its calculations.
//
// Consensus:
// https://zips.z.cash/protocol/protocol.pdf#nbits
//
// The zcashd implementation performs to_expanded() on f64,
// and then does an inverse division:
// https://github.com/zcash/zcash/blob/d6e2fada844373a8554ee085418e68de4b593a6c/src/rpc/blockchain.cpp#L46-L73
//
// But in Zebra we divide the high 128 bits of each expanded difficulty. This gives
// a similar result, because the lower 128 bits are insignificant after conversion
// to `f64` with a 53-bit mantissa.
//
// `pow_limit >> 128 / difficulty >> 128` is the same as the work calculation
// `(2^256 / pow_limit) / (2^256 / difficulty)`, but it's a bit more accurate.
//
// To simplify the calculation, we don't scale for leading zeroes. (Bitcoin's
// difficulty currently uses 68 bits, so even it would still have full precision
// using this calculation.)
// Get expanded difficulties (256 bits), these are the inverse of the work
let pow_limit: U256 = network.target_difficulty_limit().into();
let Some(difficulty) = chain_info.expected_difficulty.to_expanded() else {
return Ok(0.0);
};
// Shift out the lower 128 bits (256 bits, but the top 128 are all zeroes)
let pow_limit = pow_limit >> 128;
let difficulty = U256::from(difficulty) >> 128;
// Convert to u128 then f64.
// We could also convert U256 to String, then parse as f64, but that's slower.
let pow_limit = pow_limit.as_u128() as f64;
let difficulty = difficulty.as_u128() as f64;
// Invert the division to give approximately: `work(difficulty) / work(pow_limit)`
Ok(pow_limit / difficulty)
}

65
zebra-rpc/src/methods/get_block_template_rpcs.rs
View File

@ -25,7 +25,6 @@ use zebra_chain::{
transparent::{
self, EXTRA_ZEBRA_COINBASE_DATA, MAX_COINBASE_DATA_LEN, MAX_COINBASE_HEIGHT_DATA_LEN,
},
work::difficulty::{ParameterDifficulty as _, U256},
};
use zebra_consensus::{
block_subsidy, funding_stream_address, funding_stream_values, miner_subsidy, RouterError,
@ -36,7 +35,7 @@ use zebra_state::{ReadRequest, ReadResponse};
use crate::{
methods::{
best_chain_tip_height,
best_chain_tip_height, chain_tip_difficulty,
get_block_template_rpcs::{
constants::{
DEFAULT_SOLUTION_RATE_WINDOW_SIZE, GET_BLOCK_TEMPLATE_MEMPOOL_LONG_POLL_INTERVAL,
@ -1261,67 +1260,7 @@ where
}
async fn get_difficulty(&self) -> Result<f64> {
let network = self.network.clone();
let mut state = self.state.clone();
let request = ReadRequest::ChainInfo;
// # TODO
// - add a separate request like BestChainNextMedianTimePast, but skipping the
// consistency check, because any block's difficulty is ok for display
// - return 1.0 for a "not enough blocks in the state" error, like `zcashd`:
// <https://github.com/zcash/zcash/blob/7b28054e8b46eb46a9589d0bdc8e29f9fa1dc82d/src/rpc/blockchain.cpp#L40-L41>
let response = state
.ready()
.and_then(|service| service.call(request))
.await
.map_err(|error| ErrorObject::owned(0, error.to_string(), None::<()>))?;
let chain_info = match response {
ReadResponse::ChainInfo(info) => info,
_ => unreachable!("unmatched response to a chain info request"),
};
// This RPC is typically used for display purposes, so it is not consensus-critical.
// But it uses the difficulty consensus rules for its calculations.
//
// Consensus:
// https://zips.z.cash/protocol/protocol.pdf#nbits
//
// The zcashd implementation performs to_expanded() on f64,
// and then does an inverse division:
// https://github.com/zcash/zcash/blob/d6e2fada844373a8554ee085418e68de4b593a6c/src/rpc/blockchain.cpp#L46-L73
//
// But in Zebra we divide the high 128 bits of each expanded difficulty. This gives
// a similar result, because the lower 128 bits are insignificant after conversion
// to `f64` with a 53-bit mantissa.
//
// `pow_limit >> 128 / difficulty >> 128` is the same as the work calculation
// `(2^256 / pow_limit) / (2^256 / difficulty)`, but it's a bit more accurate.
//
// To simplify the calculation, we don't scale for leading zeroes. (Bitcoin's
// difficulty currently uses 68 bits, so even it would still have full precision
// using this calculation.)
// Get expanded difficulties (256 bits), these are the inverse of the work
let pow_limit: U256 = network.target_difficulty_limit().into();
let difficulty: U256 = chain_info
.expected_difficulty
.to_expanded()
.expect("valid blocks have valid difficulties")
.into();
// Shift out the lower 128 bits (256 bits, but the top 128 are all zeroes)
let pow_limit = pow_limit >> 128;
let difficulty = difficulty >> 128;
// Convert to u128 then f64.
// We could also convert U256 to String, then parse as f64, but that's slower.
let pow_limit = pow_limit.as_u128() as f64;
let difficulty = difficulty.as_u128() as f64;
// Invert the division to give approximately: `work(difficulty) / work(pow_limit)`
Ok(pow_limit / difficulty)
chain_tip_difficulty(self.network.clone(), self.state.clone()).await
}
async fn z_list_unified_receivers(&self, address: String) -> Result<unified_address::Response> {

121
zebra-rpc/src/methods/tests/prop.rs
View File

@ -12,20 +12,22 @@ use tower::buffer::Buffer;
use zebra_chain::{
amount::{Amount, NonNegative},
block::{self, Block, Height},
block::{Block, Height},
chain_tip::{mock::MockChainTip, ChainTip, NoChainTip},
parameters::{ConsensusBranchId, Network, NetworkUpgrade},
serialization::{ZcashDeserialize, ZcashDeserializeInto, ZcashSerialize},
serialization::{DateTime32, ZcashDeserialize, ZcashDeserializeInto, ZcashSerialize},
transaction::{self, Transaction, UnminedTx, VerifiedUnminedTx},
transparent,
value_balance::ValueBalance,
};
use zebra_consensus::ParameterCheckpoint;
use zebra_node_services::mempool;
use zebra_state::{BoxError, HashOrHeight};
use zebra_state::{BoxError, GetBlockTemplateChainInfo};
use zebra_test::mock_service::MockService;
use crate::methods::{self, types::ValuePoolBalance};
use crate::methods::{self, types::Balance};
use super::super::{
AddressBalance, AddressStrings, NetworkUpgradeStatus, RpcImpl, RpcServer, SentTransactionHash,
@ -355,31 +357,51 @@ proptest! {
fn get_blockchain_info_response_without_a_chain_tip(network in any::<Network>()) {
let (runtime, _init_guard) = zebra_test::init_async();
let _guard = runtime.enter();
let (mut mempool, mut state, rpc, mempool_tx_queue) = mock_services(network, NoChainTip);
let (mut mempool, mut state, rpc, mempool_tx_queue) = mock_services(network.clone(), NoChainTip);
// CORRECTNESS: Nothing in this test depends on real time, so we can speed it up.
tokio::time::pause();
let genesis_hash = network.genesis_hash();
runtime.block_on(async move {
let response_fut = rpc.get_blockchain_info();
let mock_state_handler = {
let mut state = state.clone();
async move {
state
.expect_request(zebra_state::ReadRequest::UsageInfo)
.await
.expect("getblockchaininfo should call mock state service with correct request")
.respond(zebra_state::ReadResponse::UsageInfo(0));
state
.expect_request(zebra_state::ReadRequest::TipPoolValues)
.await
.expect("getblockchaininfo should call mock state service with correct request")
.respond(Err(BoxError::from("no chain tip available yet")));
state.expect_request(zebra_state::ReadRequest::BlockHeader(HashOrHeight::Height(block::Height(0)))).await.expect("no chain tip available yet").respond(Err(BoxError::from("no chain tip available yet")));
state
.expect_request(zebra_state::ReadRequest::ChainInfo)
.await
.expect("getblockchaininfo should call mock state service with correct request")
.respond(zebra_state::ReadResponse::ChainInfo(GetBlockTemplateChainInfo {
tip_hash: genesis_hash,
tip_height: Height::MIN,
history_tree: Default::default(),
expected_difficulty: Default::default(),
cur_time: DateTime32::now(),
min_time: DateTime32::now(),
max_time: DateTime32::now()
}));
}
};
let (response, _) = tokio::join!(response_fut, mock_state_handler);
prop_assert_eq!(
response.err().unwrap().message().to_string(),
"no chain tip available yet".to_string()
response.unwrap().best_block_hash,
genesis_hash
);
mempool.expect_no_requests().await?;
@ -409,7 +431,7 @@ proptest! {
// get arbitrary chain tip data
let block_height = block.coinbase_height().unwrap();
let block_hash = block.hash();
let block_time = block.header.time;
let expected_size_on_disk = 1_000;
// check no requests were made during this test
runtime.block_on(async move {
@ -417,6 +439,12 @@ proptest! {
let mock_state_handler = {
let mut state = state.clone();
async move {
state
.expect_request(zebra_state::ReadRequest::UsageInfo)
.await
.expect("getblockchaininfo should call mock state service with correct request")
.respond(zebra_state::ReadResponse::UsageInfo(expected_size_on_disk));
state
.expect_request(zebra_state::ReadRequest::TipPoolValues)
.await
@ -428,24 +456,18 @@ proptest! {
});
state
.expect_request(zebra_state::ReadRequest::BlockHeader(block_hash.into()))
.expect_request(zebra_state::ReadRequest::ChainInfo)
.await
.expect("getblockchaininfo should call mock state service with correct request")
.respond(zebra_state::ReadResponse::BlockHeader {
header: Arc::new(block::Header {
time: block_time,
version: Default::default(),
previous_block_hash: Default::default(),
merkle_root: Default::default(),
commitment_bytes: Default::default(),
difficulty_threshold: Default::default(),
nonce: Default::default(),
solution: Default::default()
}),
hash: block::Hash::from([0; 32]),
height: Height::MIN,
next_block_hash: None,
});
.respond(zebra_state::ReadResponse::ChainInfo(GetBlockTemplateChainInfo {
tip_hash: block_hash,
tip_height: block_height,
history_tree: Default::default(),
expected_difficulty: Default::default(),
cur_time: DateTime32::now(),
min_time: DateTime32::now(),
max_time: DateTime32::now()
}));
}
};
@ -457,6 +479,7 @@ proptest! {
prop_assert_eq!(info.chain, network.bip70_network_name());
prop_assert_eq!(info.blocks, block_height);
prop_assert_eq!(info.best_block_hash, block_hash);
prop_assert_eq!(info.size_on_disk, expected_size_on_disk);
prop_assert!(info.estimated_height < Height::MAX);
prop_assert_eq!(
@ -480,8 +503,8 @@ proptest! {
prop_assert_eq!(u.1.status, status);
}
}
Err(_) => {
unreachable!("Test should never error with the data we are feeding it")
Err(err) => {
unreachable!("Test should never error with the data we are feeding it: {err}")
}
};
@ -512,53 +535,37 @@ proptest! {
block
},
Network::Testnet(_) => {
let block_bytes = &zebra_test::vectors::BLOCK_MAINNET_GENESIS_BYTES;
let block_bytes = &zebra_test::vectors::BLOCK_TESTNET_GENESIS_BYTES;
let block: Arc<Block> = block_bytes.zcash_deserialize_into().expect("block is valid");
block
},
};
// Genesis block fields
let block_time = genesis_block.header.time;
let block_version = genesis_block.header.version;
let block_prev_block_hash = genesis_block.header.previous_block_hash;
let block_merkle_root = genesis_block.header.merkle_root;
let block_commitment_bytes = genesis_block.header.commitment_bytes;
let block_difficulty_threshold = genesis_block.header.difficulty_threshold;
let block_nonce = genesis_block.header.nonce;
let block_solution = genesis_block.header.solution;
let block_hash = genesis_block.header.hash();
let expected_size_on_disk = 1_000;
runtime.block_on(async move {
let response_fut = rpc.get_blockchain_info();
let mock_state_handler = {
let mut state = state.clone();
async move {
state.expect_request(zebra_state::ReadRequest::TipPoolValues)
state
.expect_request(zebra_state::ReadRequest::UsageInfo)
.await
.expect("getblockchaininfo should call mock state service with correct request")
.respond(zebra_state::ReadResponse::UsageInfo(expected_size_on_disk));
state.expect_request(zebra_state::ReadRequest::TipPoolValues)
.await
.expect("getblockchaininfo should call mock state service with correct request")
.respond(Err(BoxError::from("tip values not available")));
state
.expect_request(zebra_state::ReadRequest::BlockHeader(HashOrHeight::Height(Height::MIN)))
state
.expect_request(zebra_state::ReadRequest::ChainInfo)
.await
.expect("getblockchaininfo should call mock state service with correct request")
.respond(zebra_state::ReadResponse::BlockHeader {
header: Arc::new(block::Header {
time: block_time,
version: block_version,
previous_block_hash: block_prev_block_hash,
merkle_root: block_merkle_root,
commitment_bytes: block_commitment_bytes,
difficulty_threshold: block_difficulty_threshold,
nonce: block_nonce,
solution: block_solution
}),
hash: block_hash,
height: Height::MIN,
next_block_hash: None,
});
.respond(Err(BoxError::from("chain info not available")));
}
};
@ -569,7 +576,7 @@ proptest! {
prop_assert_eq!(response.best_block_hash, genesis_block.header.hash());
prop_assert_eq!(response.chain, network.bip70_network_name());
prop_assert_eq!(response.blocks, Height::MIN);
prop_assert_eq!(response.value_pools, ValuePoolBalance::from_value_balance(ValueBalance::zero()));
prop_assert_eq!(response.value_pools, Balance::value_pools(ValueBalance::zero()));
let genesis_branch_id = NetworkUpgrade::current(&network, Height::MIN).branch_id().unwrap_or(ConsensusBranchId::RPC_MISSING_ID);
let next_height = (Height::MIN + 1).expect("genesis height plus one is next height and valid");

6
zebra-rpc/src/methods/tests/snapshot.rs
View File

@ -613,6 +613,12 @@ fn snapshot_rpc_getblockchaininfo(
// replace with:
"[Height]"
}),
".verificationprogress" => dynamic_redaction(|value, _path| {
// assert that the value looks like a valid verification progress here
assert!(value.as_f64().unwrap() <= 1.0);
// replace with:
"[f64]"
}),
})
});
}

27
zebra-rpc/src/methods/tests/snapshots/get_blockchain_info@mainnet_10.snap
View File

@ -5,33 +5,50 @@ expression: info
{
"chain": "main",
"blocks": 10,
"headers": 10,
"difficulty": 1.0,
"verificationprogress": "[f64]",
"chainwork": 0,
"pruned": false,
"size_on_disk": 0,
"commitments": 0,
"bestblockhash": "00074c46a4aa8172df8ae2ad1848a2e084e1b6989b7d9e6132adc938bf835b36",
"estimatedheight": "[Height]",
"chainSupply": {
"chainValue": 0.034375,
"chainValueZat": 3437500,
"monitored": true
},
"valuePools": [
{
"id": "transparent",
"chainValue": 0.034375,
"chainValueZat": 3437500
"chainValueZat": 3437500,
"monitored": true
},
{
"id": "sprout",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
},
{
"id": "sapling",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
},
{
"id": "orchard",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
},
{
"id": "deferred",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
}
],
"upgrades": {

27
zebra-rpc/src/methods/tests/snapshots/get_blockchain_info@testnet_10.snap
View File

@ -5,33 +5,50 @@ expression: info
{
"chain": "test",
"blocks": 10,
"headers": 10,
"difficulty": 1.0,
"verificationprogress": "[f64]",
"chainwork": 0,
"pruned": false,
"size_on_disk": 0,
"commitments": 0,
"bestblockhash": "079f4c752729be63e6341ee9bce42fbbe37236aba22e3deb82405f3c2805c112",
"estimatedheight": "[Height]",
"chainSupply": {
"chainValue": 0.034375,
"chainValueZat": 3437500,
"monitored": true
},
"valuePools": [
{
"id": "transparent",
"chainValue": 0.034375,
"chainValueZat": 3437500
"chainValueZat": 3437500,
"monitored": true
},
{
"id": "sprout",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
},
{
"id": "sapling",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
},
{
"id": "orchard",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
},
{
"id": "deferred",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
}
],
"upgrades": {

27
zebra-rpc/src/methods/tests/snapshots/get_blockchain_info_future_nu6_height@nu6testnet_10.snap
View File

@ -5,33 +5,50 @@ expression: info
{
"chain": "test",
"blocks": 10,
"headers": 10,
"difficulty": 1.0,
"verificationprogress": "[f64]",
"chainwork": 0,
"pruned": false,
"size_on_disk": 0,
"commitments": 0,
"bestblockhash": "079f4c752729be63e6341ee9bce42fbbe37236aba22e3deb82405f3c2805c112",
"estimatedheight": "[Height]",
"chainSupply": {
"chainValue": 0.034375,
"chainValueZat": 3437500,
"monitored": true
},
"valuePools": [
{
"id": "transparent",
"chainValue": 0.034375,
"chainValueZat": 3437500
"chainValueZat": 3437500,
"monitored": true
},
{
"id": "sprout",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
},
{
"id": "sapling",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
},
{
"id": "orchard",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
},
{
"id": "deferred",
"chainValue": 0.0,
"chainValueZat": 0
"chainValueZat": 0,
"monitored": false
}
],
"upgrades": {

2
zebra-rpc/src/methods/types.rs
View File

@ -3,5 +3,5 @@
mod get_blockchain_info;
mod zec;
pub use get_blockchain_info::ValuePoolBalance;
pub use get_blockchain_info::Balance;
pub use zec::Zec;

42
zebra-rpc/src/methods/types/get_blockchain_info.rs
View File

@ -10,57 +10,61 @@ use super::*;
/// A value pool's balance in Zec and Zatoshis
#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ValuePoolBalance {
pub struct Balance {
/// Name of the pool
#[serde(skip_serializing_if = "String::is_empty")]
id: String,
/// Total amount in the pool, in ZEC
chain_value: Zec<NonNegative>,
/// Total amount in the pool, in zatoshis
chain_value_zat: Amount<NonNegative>,
/// Whether the value pool balance is being monitored.
monitored: bool,
}
impl ValuePoolBalance {
/// Returns a list of [`ValuePoolBalance`]s converted from the default [`ValueBalance`].
impl Balance {
/// Returns a list of [`Balance`]s converted from the default [`ValueBalance`].
pub fn zero_pools() -> [Self; 5] {
Self::from_value_balance(Default::default())
Self::value_pools(Default::default())
}
/// Creates a new [`ValuePoolBalance`] from a pool name and its value balance.
/// Creates a new [`Balance`] from a pool name and its value balance.
pub fn new(id: impl ToString, amount: Amount<NonNegative>) -> Self {
Self {
id: id.to_string(),
chain_value: Zec::from(amount),
chain_value_zat: amount,
monitored: amount.zatoshis() != 0,
}
}
/// Creates a [`ValuePoolBalance`] for the transparent pool.
/// Creates a [`Balance`] for the transparent pool.
pub fn transparent(amount: Amount<NonNegative>) -> Self {
Self::new("transparent", amount)
}
/// Creates a [`ValuePoolBalance`] for the Sprout pool.
/// Creates a [`Balance`] for the Sprout pool.
pub fn sprout(amount: Amount<NonNegative>) -> Self {
Self::new("sprout", amount)
}
/// Creates a [`ValuePoolBalance`] for the Sapling pool.
/// Creates a [`Balance`] for the Sapling pool.
pub fn sapling(amount: Amount<NonNegative>) -> Self {
Self::new("sapling", amount)
}
/// Creates a [`ValuePoolBalance`] for the Orchard pool.
/// Creates a [`Balance`] for the Orchard pool.
pub fn orchard(amount: Amount<NonNegative>) -> Self {
Self::new("orchard", amount)
}
/// Creates a [`ValuePoolBalance`] for the Deferred pool.
/// Creates a [`Balance`] for the Deferred pool.
pub fn deferred(amount: Amount<NonNegative>) -> Self {
Self::new("deferred", amount)
}
/// Converts a [`ValueBalance`] to a list of [`ValuePoolBalance`]s.
pub fn from_value_balance(value_balance: ValueBalance<NonNegative>) -> [Self; 5] {
/// Converts a [`ValueBalance`] to a list of [`Balance`]s.
pub fn value_pools(value_balance: ValueBalance<NonNegative>) -> [Self; 5] {
[
Self::transparent(value_balance.transparent_amount()),
Self::sprout(value_balance.sprout_amount()),
@ -69,4 +73,18 @@ impl ValuePoolBalance {
Self::deferred(value_balance.deferred_amount()),
]
}
/// Converts a [`ValueBalance`] to a [`Balance`] representing the total chain supply.
pub fn chain_supply(value_balance: ValueBalance<NonNegative>) -> Self {
Self::value_pools(value_balance)
.into_iter()
.reduce(|a, b| {
Balance::new(
"",
(a.chain_value_zat + b.chain_value_zat)
.expect("sum of value balances should not overflow"),
)
})
.expect("at least one pool")
}
}

5
zebra-state/src/lib.rs
View File

@ -48,7 +48,7 @@ pub use request::{
#[cfg(feature = "indexer")]
pub use request::Spend;
pub use response::{KnownBlock, MinedTx, ReadResponse, Response};
pub use response::{GetBlockTemplateChainInfo, KnownBlock, MinedTx, ReadResponse, Response};
pub use service::{
chain_tip::{ChainTipBlock, ChainTipChange, ChainTipSender, LatestChainTip, TipAction},
check, init, init_read_only,
@ -73,9 +73,6 @@ pub use service::finalized_state::{
pub use service::{finalized_state::ZebraDb, ReadStateService};
#[cfg(feature = "getblocktemplate-rpcs")]
pub use response::GetBlockTemplateChainInfo;
// Allow use in external tests
#[cfg(any(test, feature = "proptest-impl"))]
pub use service::{

7
zebra-state/src/request.rs
View File

@ -866,6 +866,10 @@ impl Request {
/// A read-only query about the chain state, via the
/// [`ReadStateService`](crate::service::ReadStateService).
pub enum ReadRequest {
/// Returns [`ReadResponse::UsageInfo(num_bytes: u64)`](ReadResponse::UsageInfo)
/// with the current disk space usage in bytes.
UsageInfo,
/// Returns [`ReadResponse::Tip(Option<(Height, block::Hash)>)`](ReadResponse::Tip)
/// with the current best chain tip.
Tip,
@ -1096,7 +1100,6 @@ pub enum ReadRequest {
/// * [`ReadResponse::BlockHash(None)`](ReadResponse::BlockHash) otherwise.
BestChainBlockHash(block::Height),
#[cfg(feature = "getblocktemplate-rpcs")]
/// Get state information from the best block chain.
///
/// Returns [`ReadResponse::ChainInfo(info)`](ReadResponse::ChainInfo) where `info` is a
@ -1135,6 +1138,7 @@ pub enum ReadRequest {
impl ReadRequest {
fn variant_name(&self) -> &'static str {
match self {
ReadRequest::UsageInfo => "usage_info",
ReadRequest::Tip => "tip",
ReadRequest::TipPoolValues => "tip_pool_values",
ReadRequest::Depth(_) => "depth",
@ -1161,7 +1165,6 @@ impl ReadRequest {
ReadRequest::BestChainBlockHash(_) => "best_chain_block_hash",
#[cfg(feature = "indexer")]
ReadRequest::SpendingTransactionId(_) => "spending_transaction_id",
#[cfg(feature = "getblocktemplate-rpcs")]
ReadRequest::ChainInfo => "chain_info",
#[cfg(feature = "getblocktemplate-rpcs")]
ReadRequest::SolutionRate { .. } => "solution_rate",

14
zebra-state/src/response.rs
View File

@ -13,7 +13,6 @@ use zebra_chain::{
value_balance::ValueBalance,
};
#[cfg(feature = "getblocktemplate-rpcs")]
use zebra_chain::work::difficulty::CompactDifficulty;
// Allow *only* these unused imports, so that rustdoc link resolution
@ -135,6 +134,9 @@ impl MinedTx {
/// A response to a read-only
/// [`ReadStateService`](crate::service::ReadStateService)'s [`ReadRequest`].
pub enum ReadResponse {
/// Response to [`ReadRequest::UsageInfo`] with the current best chain tip.
UsageInfo(u64),
/// Response to [`ReadRequest::Tip`] with the current best chain tip.
Tip(Option<(block::Height, block::Hash)>),
@ -241,7 +243,6 @@ pub enum ReadResponse {
/// Response to [`ReadRequest::BestChainBlockHash`] with the specified block hash.
BlockHash(Option<block::Hash>),
#[cfg(feature = "getblocktemplate-rpcs")]
/// Response to [`ReadRequest::ChainInfo`] with the state
/// information needed by the `getblocktemplate` RPC method.
ChainInfo(GetBlockTemplateChainInfo),
@ -260,7 +261,6 @@ pub enum ReadResponse {
}
/// A structure with the information needed from the state to build a `getblocktemplate` RPC response.
#[cfg(feature = "getblocktemplate-rpcs")]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct GetBlockTemplateChainInfo {
// Data fetched directly from the state tip.
@ -337,7 +337,8 @@ impl TryFrom<ReadResponse> for Response {
ReadResponse::ValidBestChainTipNullifiersAndAnchors => Ok(Response::ValidBestChainTipNullifiersAndAnchors),
ReadResponse::TipPoolValues { .. }
ReadResponse::UsageInfo(_)
| ReadResponse::TipPoolValues { .. }
| ReadResponse::TransactionIdsForBlock(_)
| ReadResponse::SaplingTree(_)
| ReadResponse::OrchardTree(_)
@ -345,7 +346,8 @@ impl TryFrom<ReadResponse> for Response {
| ReadResponse::OrchardSubtrees(_)
| ReadResponse::AddressBalance(_)
| ReadResponse::AddressesTransactionIds(_)
| ReadResponse::AddressUtxos(_) => {
| ReadResponse::AddressUtxos(_)
| ReadResponse::ChainInfo(_) => {
Err("there is no corresponding Response for this ReadResponse")
}
@ -356,7 +358,7 @@ impl TryFrom<ReadResponse> for Response {
ReadResponse::ValidBlockProposal => Ok(Response::ValidBlockProposal),
#[cfg(feature = "getblocktemplate-rpcs")]
ReadResponse::ChainInfo(_) | ReadResponse::SolutionRate(_) | ReadResponse::TipBlockSize(_) => {
ReadResponse::SolutionRate(_) | ReadResponse::TipBlockSize(_) => {
Err("there is no corresponding Response for this ReadResponse")
}
}

21
zebra-state/src/service.rs
View File

@ -1173,6 +1173,24 @@ impl Service<ReadRequest> for ReadStateService {
let span = Span::current();
match req {
// Used by the `getblockchaininfo` RPC.
ReadRequest::UsageInfo => {
let db = self.db.clone();
tokio::task::spawn_blocking(move || {
span.in_scope(move || {
// The work is done in the future.
let db_size = db.size();
timer.finish(module_path!(), line!(), "ReadRequest::UsageInfo");
Ok(ReadResponse::UsageInfo(db_size))
})
})
.wait_for_panics()
}
// Used by the StateService.
ReadRequest::Tip => {
let state = self.clone();
@ -1813,8 +1831,7 @@ impl Service<ReadRequest> for ReadStateService {
.wait_for_panics()
}
// Used by get_block_template RPC.
#[cfg(feature = "getblocktemplate-rpcs")]
// Used by get_block_template and getblockchaininfo RPCs.
ReadRequest::ChainInfo => {
let state = self.clone();
let latest_non_finalized_state = self.latest_non_finalized_state();

21
zebra-state/src/service/finalized_state/disk_db.rs
View File

@ -570,6 +570,27 @@ impl DiskDb {
);
}
/// Returns the estimated total disk space usage of the database.
pub fn size(&self) -> u64 {
let db: &Arc<DB> = &self.db;
let db_options = DiskDb::options();
let mut total_size_on_disk = 0;
for cf_descriptor in DiskDb::construct_column_families(&db_options, db.path(), &[]).iter() {
let cf_name = &cf_descriptor.name();
let cf_handle = db
.cf_handle(cf_name)
.expect("Column family handle must exist");
total_size_on_disk += db
.property_int_value_cf(cf_handle, "rocksdb.total-sst-files-size")
.ok()
.flatten()
.unwrap_or(0);
}
total_size_on_disk
}
/// When called with a secondary DB instance, tries to catch up with the primary DB instance
pub fn try_catch_up_with_primary(&self) -> Result<(), rocksdb::Error> {
self.db.try_catch_up_with_primary()

5
zebra-state/src/service/finalized_state/zebra_db.rs
View File

@ -343,6 +343,11 @@ impl ZebraDb {
pub fn print_db_metrics(&self) {
self.db.print_db_metrics();
}
/// Returns the estimated total disk space usage of the database.
pub fn size(&self) -> u64 {
self.db.size()
}
}
impl Drop for ZebraDb {

4
zebra-state/src/service/read.rs
View File

@ -16,12 +16,10 @@ use crate::service;
pub mod address;
pub mod block;
pub mod difficulty;
pub mod find;
pub mod tree;
#[cfg(feature = "getblocktemplate-rpcs")]
pub mod difficulty;
#[cfg(test)]
mod tests;

1
zebra-state/src/service/read/difficulty.rs
View File

@ -82,6 +82,7 @@ pub fn get_block_template_chain_info(
///
/// Returns the solution rate per second for the current best chain, or `None` if
/// the `start_hash` and at least 1 block below it are not found in the chain.
#[allow(unused)]
pub fn solution_rate(
non_finalized_state: &NonFinalizedState,
db: &ZebraDb,

1
zebra-state/src/service/read/tree.rs
View File

@ -197,7 +197,6 @@ where
}
}
#[cfg(feature = "getblocktemplate-rpcs")]
/// Get the history tree of the provided chain.
pub fn history_tree<C>(
chain: Option<C>,