Inbound FindBlocks and FindHeaders

zebra-state/src/request.rs

@@ -239,4 +239,18 @@ pub enum Request {
     /// Code making this request should apply a timeout layer to the service to
     /// handle missing UTXOs.
     AwaitUtxo(transparent::OutPoint),
+
+    /// Finds the intersection of the block hashes provided by a peer, and the local best chain.
+    /// Returns a list of block hashes, starting at the child of the intersection, and extending towards the tip.
+    ///
+    /// Returns
+    ///
+    /// [`Response::BlockHashes(Vec<block::Hash>)`](Response::Hashes) with max of 500 block hashes.
+    /// See https://en.bitcoin.it/wiki/Protocol_documentation#getblocks
+    FindBlockHashes {
+        /// Hashes of known blocks, ordered from highest height to lowest height.
+        known_blocks: Vec<block::Hash>,
+        /// Optionally, the last block hash to request.
+        stop: Option<block::Hash>,
+    },
 }

zebra-state/src/response.rs

@@ -33,6 +33,9 @@ pub enum Response {
     /// Response to [`Request::Block`] with the specified block.
     Block(Option<Arc<Block>>),
 
-    /// The response to a `AwaitUtxo` request
+    /// The response to a `AwaitUtxo` request.
     Utxo(Utxo),
+
+    /// The response to a `FindBlockHashes` request.
+    BlockHashes(Vec<block::Hash>),
 }

zebra-state/src/service.rs

@@ -270,6 +270,105 @@ impl StateService {
             state: IterState::NonFinalized(hash),
         }
     }
+
+    /// Return a list of block hashes in the best chain, following the first matching hash in `known_blocks`.
+    ///
+    /// Starts from the first matching hash in the best chain, ignoring all other hashes in `known_blocks`.
+    /// Only matches and returns hashes from the best chain, including non-finalized blocks.
+    /// Stops the list of hashes after:
+    ///   * adding the non-finalized best tip,
+    ///   * adding the stop hash to the list, if it is in the best chain, or
+    ///   * adding 500 hashes to the list.
+    pub fn find_chain_hashes(
+        &self,
+        known_blocks: Vec<block::Hash>,
+        stop: Option<block::Hash>,
+    ) -> Vec<block::Hash> {
+        let mut res: Vec<block::Hash> = Vec::new();
+
+        // Known blocks can't be empty
+        if known_blocks.is_empty() {
+            return res;
+        }
+
+        // Get chain tip
+        let (chain_tip_height, ..) = self.tip().expect("tip must always be available");
+
+        // Get requested tip
+        let locator_tip_hash = known_blocks.first().expect("we must have a tip hash");
+        let locator_tip_height = self
+            .height_by_hash(*locator_tip_hash)
+            .expect("tip hash must have a height");
+        let chain = self.chain(*locator_tip_hash);
+
+        // Requested tip must be below our chain tip
+        if locator_tip_height >= chain_tip_height {
+            return res;
+        }
+
+        tracing::info!(
+            "REQUESTED TIP: {:?} {:?}",
+            locator_tip_height,
+            locator_tip_hash
+        );
+
+        // Block locator are not continuous but we need to make sure all the blocks
+        // provided are in our chain and in the right order.
+        let mut collect_block_locator: Vec<block::Hash> = Vec::new();
+        let mut index = 0;
+        for block in chain {
+            // We get out of the loop as soon as we collect a vector of equal
+            // lenght of the provided.
+            if collect_block_locator.len() == known_blocks.len() {
+                break;
+            }
+
+            if block.hash() == known_blocks[index] {
+                collect_block_locator.push(block.hash());
+                index += 1
+            }
+        }
+
+        // If the 2 vectors are not equal we cant continue.
+        if collect_block_locator != known_blocks {
+            return res;
+        }
+
+        const MAX_FIND_BLOCK_HASHES_RESULTS: usize = 500;
+
+        // Compute a new tip, make sure it is below our chain tip.
+        let new_tip_height = block::Height(std::cmp::min(
+            locator_tip_height.0 + MAX_FIND_BLOCK_HASHES_RESULTS as u32,
+            chain_tip_height.0,
+        ));
+        let new_tip_hash = self.hash(new_tip_height).expect("new tip must have a hash");
+
+        // Get a new chain starting at the new "requested" tip.
+        let new_chain = self.chain(new_tip_hash);
+
+        for block in new_chain {
+            // If we get the requested tip we are over
+            if block.hash() == *locator_tip_hash {
+                break;
+            }
+
+            res.push(block.hash());
+
+            // Check the stop parameter
+            if stop == Some(block.hash()) {
+                break;
+            }
+
+            tracing::info!(
+                "RESPONSE: {:?} {:?}",
+                self.height_by_hash(block.hash())
+                    .expect("if hash is in the state then it should have an associated height"),
+                block.hash()
+            );
+        }
+        res.reverse();
+        res
+    }
 }
 
 struct Iter<'a> {
@@ -452,6 +551,10 @@ impl Service<Request> for StateService {
 
                 fut.boxed()
             }
+            Request::FindBlockHashes { known_blocks, stop } => {
+                let res = self.find_chain_hashes(known_blocks, stop);
+                async move { Ok(Response::BlockHashes(res)) }.boxed()
+            }
         }
     }
 }

zebrad/src/components/inbound.rs

@@ -155,9 +155,20 @@ impl Service<zn::Request> for Inbound {
                 debug!("ignoring unimplemented request");
                 async { Ok(zn::Response::Nil) }.boxed()
             }
-            zn::Request::FindBlocks { .. } => {
-                debug!("ignoring unimplemented request");
-                async { Ok(zn::Response::Nil) }.boxed()
+            zn::Request::FindBlocks { known_blocks, stop } => {
+                let request = zs::Request::FindBlockHashes { known_blocks, stop };
+                self.state.call(request).map_ok(|resp| match resp {
+                        zs::Response::BlockHashes(hashes) => {
+                            if hashes.is_empty() {
+                                zn::Response::Nil
+                            }
+                            else {
+                                zn::Response::BlockHashes(hashes)
+                            }
+                        },
+                        _ => unreachable!("zebra-state should always respond to a `FindBlocks` request with a `Vec<block::Hash>` response"),
+                    })
+                .boxed()
             }
             zn::Request::FindHeaders { .. } => {
                 debug!("ignoring unimplemented request");