merge-queue: embarking main (402ed3e) and [#5884 + #5925] together

zebra-chain/src/work/equihash.rs

@@ -59,6 +59,12 @@ impl Solution {
 
         Ok(())
     }
+
+    #[cfg(feature = "getblocktemplate-rpcs")]
+    /// Returns a [`Solution`] of `[0; SOLUTION_SIZE]` to be used in block proposals.
+    pub fn for_proposal() -> Self {
+        Self([0; SOLUTION_SIZE])
+    }
 }
 
 impl PartialEq<Solution> for Solution {

zebra-rpc/src/methods.rs

@@ -1193,7 +1193,7 @@ pub enum GetBlock {
 ///
 /// Also see the notes for the [`Rpc::get_best_block_hash`] and `get_block_hash` methods.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
-pub struct GetBlockHash(#[serde(with = "hex")] block::Hash);
+pub struct GetBlockHash(#[serde(with = "hex")] pub block::Hash);
 
 /// Response to a `z_gettreestate` RPC request.
 ///

zebra-rpc/src/methods/get_block_template_rpcs/get_block_template.rs

@@ -108,7 +108,7 @@ where
         + Sync
         + 'static,
 {
-    let Ok(block) = block_proposal_bytes.zcash_deserialize_into() else {
+    let Ok(block) = block_proposal_bytes.zcash_deserialize_into::<block::Block>() else {
          return Ok(ProposalRejectReason::Rejected.into())
     };
 
@@ -125,7 +125,14 @@ where
 
     Ok(chain_verifier_response
         .map(|_hash| ProposalResponse::Valid)
-        .unwrap_or_else(|_| ProposalRejectReason::Rejected.into())
+        .unwrap_or_else(|verify_chain_error| {
+            tracing::info!(
+                verify_chain_error,
+                "Got error response from chain_verifier CheckProposal request"
+            );
+
+            ProposalRejectReason::Rejected.into()
+        })
         .into())
 }
 

zebra-rpc/src/methods/get_block_template_rpcs/types/get_block_template.rs

@@ -1,4 +1,5 @@
-//! The `GetBlockTempate` type is the output of the `getblocktemplate` RPC method.
+//! The `GetBlockTempate` type is the output of the `getblocktemplate` RPC method in the
+//! default 'template' mode. See [`ProposalResponse`] for the output in 'proposal' mode.
 
 use zebra_chain::{
     amount,
@@ -27,8 +28,10 @@ use crate::methods::{
 };
 
 pub mod parameters;
+pub mod proposal;
 
 pub use parameters::*;
+pub use proposal::*;
 
 /// A serialized `getblocktemplate` RPC response in template mode.
 #[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
@@ -283,33 +286,6 @@ impl GetBlockTemplate {
     }
 }
 
-/// Error response to a `getblocktemplate` RPC request in proposal mode.
-#[derive(Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "kebab-case")]
-pub enum ProposalRejectReason {
-    /// Block proposal rejected as invalid.
-    Rejected,
-}
-
-/// Response to a `getblocktemplate` RPC request in proposal mode.
-///
-/// See <https://en.bitcoin.it/wiki/BIP_0023#Block_Proposal>
-#[derive(Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-#[serde(untagged, rename_all = "kebab-case")]
-pub enum ProposalResponse {
-    /// Block proposal was rejected as invalid, returns `reject-reason` and server `capabilities`.
-    ErrorResponse {
-        /// Reason the proposal was invalid as-is.
-        reject_reason: ProposalRejectReason,
-
-        /// The getblocktemplate RPC capabilities supported by Zebra.
-        capabilities: Vec<String>,
-    },
-
-    /// Block proposal was successfully validated, returns null.
-    Valid,
-}
-
 #[derive(Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 #[serde(untagged)]
 /// A `getblocktemplate` RPC response.
@@ -320,30 +296,3 @@ pub enum Response {
     /// `getblocktemplate` RPC request in proposal mode.
     ProposalMode(ProposalResponse),
 }
-
-impl From<ProposalRejectReason> for ProposalResponse {
-    fn from(reject_reason: ProposalRejectReason) -> Self {
-        Self::ErrorResponse {
-            reject_reason,
-            capabilities: GetBlockTemplate::capabilities(),
-        }
-    }
-}
-
-impl From<ProposalRejectReason> for Response {
-    fn from(error_response: ProposalRejectReason) -> Self {
-        Self::ProposalMode(ProposalResponse::from(error_response))
-    }
-}
-
-impl From<ProposalResponse> for Response {
-    fn from(proposal_response: ProposalResponse) -> Self {
-        Self::ProposalMode(proposal_response)
-    }
-}
-
-impl From<GetBlockTemplate> for Response {
-    fn from(template: GetBlockTemplate) -> Self {
-        Self::TemplateMode(Box::new(template))
-    }
-}

zebra-rpc/src/methods/get_block_template_rpcs/types/get_block_template/proposal.rs

@@ -0,0 +1,59 @@
+//! `ProposalResponse` is the output of the `getblocktemplate` RPC method in 'proposal' mode.
+
+use super::{GetBlockTemplate, Response};
+
+/// Error response to a `getblocktemplate` RPC request in proposal mode.
+///
+/// See <https://en.bitcoin.it/wiki/BIP_0022#Appendix:_Example_Rejection_Reasons>
+#[derive(Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum ProposalRejectReason {
+    /// Block proposal rejected as invalid.
+    Rejected,
+}
+
+/// Response to a `getblocktemplate` RPC request in proposal mode.
+///
+/// See <https://en.bitcoin.it/wiki/BIP_0023#Block_Proposal>
+#[derive(Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(untagged, rename_all = "kebab-case")]
+pub enum ProposalResponse {
+    /// Block proposal was rejected as invalid, returns `reject-reason` and server `capabilities`.
+    ErrorResponse {
+        /// Reason the proposal was invalid as-is.
+        reject_reason: ProposalRejectReason,
+
+        /// The getblocktemplate RPC capabilities supported by Zebra.
+        capabilities: Vec<String>,
+    },
+
+    /// Block proposal was successfully validated, returns null.
+    Valid,
+}
+
+impl From<ProposalRejectReason> for ProposalResponse {
+    fn from(reject_reason: ProposalRejectReason) -> Self {
+        Self::ErrorResponse {
+            reject_reason,
+            capabilities: GetBlockTemplate::capabilities(),
+        }
+    }
+}
+
+impl From<ProposalRejectReason> for Response {
+    fn from(error_response: ProposalRejectReason) -> Self {
+        Self::ProposalMode(ProposalResponse::from(error_response))
+    }
+}
+
+impl From<ProposalResponse> for Response {
+    fn from(proposal_response: ProposalResponse) -> Self {
+        Self::ProposalMode(proposal_response)
+    }
+}
+
+impl From<GetBlockTemplate> for Response {
+    fn from(template: GetBlockTemplate) -> Self {
+        Self::TemplateMode(Box::new(template))
+    }
+}

zebra-rpc/src/methods/get_block_template_rpcs/types/transaction.rs

@@ -16,7 +16,7 @@ where
 {
     /// The hex-encoded serialized data for this transaction.
     #[serde(with = "hex")]
-    pub(crate) data: SerializedTransaction,
+    pub data: SerializedTransaction,
 
     /// The transaction ID of this transaction.
     #[serde(with = "hex")]

zebra-rpc/src/methods/tests/snapshot/get_block_template_rpcs.rs

@@ -106,6 +106,7 @@ pub async fn test_responses<State, ReadState>(
     let fake_cur_time = DateTime32::from(1654008617);
     // nu5 block time + 123
     let fake_max_time = DateTime32::from(1654008728);
+    let fake_difficulty = CompactDifficulty::from(ExpandedDifficulty::from(U256::one()));
 
     let (mock_chain_tip, mock_chain_tip_sender) = MockChainTip::new();
     mock_chain_tip_sender.send_best_tip_height(fake_tip_height);
@@ -181,7 +182,7 @@ pub async fn test_responses<State, ReadState>(
             .expect_request_that(|req| matches!(req, ReadRequest::ChainInfo))
             .await
             .respond(ReadResponse::ChainInfo(GetBlockTemplateChainInfo {
-                expected_difficulty: CompactDifficulty::from(ExpandedDifficulty::from(U256::one())),
+                expected_difficulty: fake_difficulty,
                 tip_height: fake_tip_height,
                 tip_hash: fake_tip_hash,
                 cur_time: fake_cur_time,
@@ -235,7 +236,7 @@ pub async fn test_responses<State, ReadState>(
             .expect_request_that(|req| matches!(req, ReadRequest::ChainInfo))
             .await
             .respond(ReadResponse::ChainInfo(GetBlockTemplateChainInfo {
-                expected_difficulty: CompactDifficulty::from(ExpandedDifficulty::from(U256::one())),
+                expected_difficulty: fake_difficulty,
                 tip_height: fake_tip_height,
                 tip_hash: fake_tip_hash,
                 cur_time: fake_cur_time,

zebra-rpc/src/methods/tests/vectors.rs

@@ -953,6 +953,7 @@ async fn rpc_getblocktemplate_mining_address(use_p2pkh: bool) {
     let fake_cur_time = DateTime32::from(1654008617);
     // nu5 block time + 123
     let fake_max_time = DateTime32::from(1654008728);
+    let fake_difficulty = CompactDifficulty::from(ExpandedDifficulty::from(U256::one()));
 
     let (mock_chain_tip, mock_chain_tip_sender) = MockChainTip::new();
     mock_chain_tip_sender.send_best_tip_height(fake_tip_height);
@@ -976,7 +977,7 @@ async fn rpc_getblocktemplate_mining_address(use_p2pkh: bool) {
             .expect_request_that(|req| matches!(req, ReadRequest::ChainInfo))
             .await
             .respond(ReadResponse::ChainInfo(GetBlockTemplateChainInfo {
-                expected_difficulty: CompactDifficulty::from(ExpandedDifficulty::from(U256::one())),
+                expected_difficulty: fake_difficulty,
                 tip_height: fake_tip_height,
                 tip_hash: fake_tip_hash,
                 cur_time: fake_cur_time,

zebra-state/src/response.rs

@@ -166,16 +166,14 @@ pub struct GetBlockTemplateChainInfo {
     /// Depends on the `tip_hash`.
     pub history_tree: Arc<zebra_chain::history_tree::HistoryTree>,
 
-    // Data derived from the state tip and recent blocks.
+    // Data derived from the state tip and recent blocks, and the current local clock.
     //
     /// The expected difficulty of the candidate block.
-    /// Depends on the `tip_hash`.
+    /// Depends on the `tip_hash`, and the local clock on testnet.
     pub expected_difficulty: CompactDifficulty,
 
-    // Data derived from the state tip and recent blocks, and the current local clock.
-    //
     /// The current system time, adjusted to fit within `min_time` and `max_time`.
-    /// Depends on the local clock and the `tip_hash`.
+    /// Always depends on the local clock and the `tip_hash`.
     pub cur_time: DateTime32,
 
     /// The mininimum time the miner can use in this block.

zebra-state/src/service/read/difficulty.rs

@@ -26,6 +26,11 @@ use crate::{
     BoxError, GetBlockTemplateChainInfo,
 };
 
+/// The amount of extra time we allow for a miner to mine a standard difficulty block on testnet.
+///
+/// This is a Zebra-specific standard rule.
+pub const EXTRA_TIME_TO_MINE_A_BLOCK: u32 = POST_BLOSSOM_POW_TARGET_SPACING * 2;
+
 /// Returns the [`GetBlockTemplateChainInfo`] for the current best chain.
 ///
 /// # Panics
@@ -117,7 +122,9 @@ pub fn solution_rate(
 }
 
 /// Do a consistency check by checking the finalized tip before and after all other database queries.
-/// Returns and error if the tip obtained before and after is not the same.
+///
+/// Returns the state tip, recent blocks in reverse order from the tip, and the tip history tree.
+/// Returns an error if the tip obtained before and after is not the same.
 ///
 /// # Panics
 ///
@@ -173,6 +180,8 @@ fn relevant_chain_and_history_tree(
 
 /// Returns the [`GetBlockTemplateChainInfo`] for the current best chain.
 ///
+/// The `relevant_chain` has recent blocks in reverse order from the tip.
+///
 /// See [`get_block_template_chain_info()`] for details.
 fn difficulty_time_and_history_tree(
     relevant_chain: [Arc<Block>; POW_ADJUSTMENT_BLOCK_SPAN],
@@ -227,12 +236,13 @@ fn difficulty_time_and_history_tree(
         network,
         relevant_data.iter().cloned(),
     );
+    let expected_difficulty = difficulty_adjustment.expected_difficulty_threshold();
 
     let mut result = GetBlockTemplateChainInfo {
         tip_hash,
         tip_height,
         history_tree,
-        expected_difficulty: difficulty_adjustment.expected_difficulty_threshold(),
+        expected_difficulty,
         cur_time,
         min_time,
         max_time,
@@ -244,6 +254,8 @@ fn difficulty_time_and_history_tree(
 }
 
 /// Adjust the difficulty and time for the testnet minimum difficulty rule.
+///
+/// The `relevant_data` has recent block difficulties and times in reverse order from the tip.
 fn adjust_difficulty_and_time_for_testnet(
     result: &mut GetBlockTemplateChainInfo,
     network: Network,
@@ -275,7 +287,8 @@ fn adjust_difficulty_and_time_for_testnet(
     // There is still a small chance that miners will produce an invalid block, if they are
     // just below the max time, and don't check it.
 
-    let previous_block_time = relevant_data.last().expect("has at least one block").1;
+    // The tip is the first relevant data block, because they are in reverse order.
+    let previous_block_time = relevant_data.first().expect("has at least one block").1;
     let previous_block_time: DateTime32 = previous_block_time
         .try_into()
         .expect("valid blocks have in-range times");
@@ -296,28 +309,40 @@ fn adjust_difficulty_and_time_for_testnet(
         .expect("a valid block time plus a small constant is in-range");
 
     // If a miner is likely to find a block with the cur_time and standard difficulty
+    // within a target block interval or two, keep the original difficulty.
+    // Otherwise, try to use the minimum difficulty.
+    //
+    // This is a Zebra-specific standard rule.
     //
     // We don't need to undo the clamping here:
     // - if cur_time is clamped to min_time, then we're more likely to have a minimum
     //    difficulty block, which makes mining easier;
-    // - if cur_time gets clamped to max_time, this is already a minimum difficulty block.
+    // - if cur_time gets clamped to max_time, this is almost always a minimum difficulty block.
     let local_std_difficulty_limit = std_difficulty_max_time
-        .checked_sub(Duration32::from_seconds(
-            POST_BLOSSOM_POW_TARGET_SPACING * 2,
-        ))
+        .checked_sub(Duration32::from_seconds(EXTRA_TIME_TO_MINE_A_BLOCK))
         .expect("a valid block time minus a small constant is in-range");
 
     if result.cur_time <= local_std_difficulty_limit {
-        // Standard difficulty: the max time needs to exclude min difficulty blocks
-        result.max_time = std_difficulty_max_time;
+        // Standard difficulty: the cur and max time need to exclude min difficulty blocks
+
+        // The maximum time can only be decreased, and only as far as min_time.
+        // The old minimum is still required by other consensus rules.
+        result.max_time = std_difficulty_max_time.clamp(result.min_time, result.max_time);
+
+        // The current time only needs to be decreased if the max_time decreased past it.
+        // Decreasing the current time can't change the difficulty.
+        result.cur_time = result.cur_time.clamp(result.min_time, result.max_time);
     } else {
-        // Minimum difficulty: the min and cur time need to exclude min difficulty blocks
-        result.min_time = min_difficulty_min_time;
-        if result.cur_time < min_difficulty_min_time {
-            result.cur_time = min_difficulty_min_time;
-        }
+        // Minimum difficulty: the min and cur time need to exclude std difficulty blocks
+
+        // The minimum time can only be increased, and only as far as max_time.
+        // The old maximum is still required by other consensus rules.
+        result.min_time = min_difficulty_min_time.clamp(result.min_time, result.max_time);
+
+        // The current time only needs to be increased if the min_time increased past it.
+        result.cur_time = result.cur_time.clamp(result.min_time, result.max_time);
 
-        // And then the difficulty needs to be updated for cur_time
+        // And then the difficulty needs to be updated for cur_time.
         result.expected_difficulty = AdjustedDifficulty::new_from_header_time(
             result.cur_time.into(),
             previous_block_height,

zebrad/Cargo.toml

@@ -174,6 +174,7 @@ tonic-build = { version = "0.8.0", optional = true }
 [dev-dependencies]
 abscissa_core = { version = "0.5", features = ["testing"] }
 hex = "0.4.3"
+jsonrpc-core = "18.0.0"
 once_cell = "1.17.0"
 regex = "1.7.1"
 semver = "1.0.16"