fix: reduce the bitcoin adapter maximum response size to 1MB for testnet4 (#3769)

Before, the total response of the `get_successors` rpc in the bitcoin
adapter was 2MB, regardless of the bitcoin network. In the worst case,
this lead to the response containing either :
- ~100 medium 20KB blocks, each with many small transactions, or
- 2 large 1MB blocks, each with really many small transactions

Both of those cases made serialization take really long, and the
`get_successors` request would exceed the [50ms timeout in
consensus](https://github.com/dfinity/ic/blob/b7a0b3d3b896cdaabc06c0ee6cd13cd54c939e67/rs/config/src/bitcoin_payload_builder_config.rs#L12).

After, the maximum response size is reduced to just 1MB for the testnet4
network. This speeds up the serialization, while not sacrificing the
canister performance too much (on average, there will be 2x more
requests to the adapter when the canister starts up, but after it
reaches the tip, it anyway receives maximum 1 block per request).

Note that the Bitcoin mainnet network can't suffer from the same problem
because:
1. Its blocks are quicker to serialize due to the transactions being
larger
2. There are no storm blocks / crazy difficulty variations on it, hence
the adapter will always send 1 block per response (which is anyway
enforced after block height
[750_000](https://github.com/dfinity/ic/blob/b7a0b3d3b896cdaabc06c0ee6cd13cd54c939e67/rs/bitcoin/adapter/src/get_successors_handler.rs#L236)).

Author: mihailjianu1

Cargo.lock

@@ -22,6 +22,7 @@ DEPENDENCIES = [
     "@crate_index//:serde_json",
     "@crate_index//:slog",
     "@crate_index//:slog-async",
+    "@crate_index//:static_assertions",
     "@crate_index//:thiserror",
     "@crate_index//:tokio",
     "@crate_index//:tokio-socks",

rs/bitcoin/adapter/BUILD.bazel

@@ -30,6 +30,7 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 slog = { workspace = true }
 slog-async = { workspace = true }
+static_assertions = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
 tokio-socks = "0.5.1"

rs/bitcoin/adapter/Cargo.toml

@@ -5,6 +5,7 @@ use std::{
 
 use bitcoin::{block::Header as BlockHeader, Block, BlockHash, Network};
 use ic_metrics::MetricsRegistry;
+use static_assertions::const_assert_eq;
 use tokio::sync::mpsc::Sender;
 use tonic::Status;
 
@@ -21,6 +22,10 @@ use crate::{
 // for pagination on the replica side to work as expected.
 const MAX_RESPONSE_SIZE: usize = 2_000_000;
 
+// Lower than mainnet's response size. The main reason is large serialization time
+// for large blocks.
+const TESTNET4_MAX_RESPONSE_SIZE: usize = 1_000_000;
+
 // Max number of next block headers that can be returned in the `GetSuccessorsResponse`.
 const MAX_NEXT_BLOCK_HEADERS_LENGTH: usize = 100;
 
@@ -38,6 +43,14 @@ const MAX_NEXT_BYTES: usize = MAX_NEXT_BLOCK_HEADERS_LENGTH * BLOCK_HEADER_SIZE;
 // Having this as a soft limit as necessary to prevent large blocks from stalling consensus.
 const MAX_BLOCKS_BYTES: usize = MAX_RESPONSE_SIZE - MAX_NEXT_BYTES;
 
+const TESTNET4_MAX_BLOCKS_BYTES: usize = TESTNET4_MAX_RESPONSE_SIZE - MAX_NEXT_BYTES;
+
+const_assert_eq!(MAX_NEXT_BYTES + MAX_BLOCKS_BYTES, MAX_RESPONSE_SIZE);
+const_assert_eq!(
+    MAX_NEXT_BYTES + TESTNET4_MAX_BLOCKS_BYTES,
+    TESTNET4_MAX_RESPONSE_SIZE
+);
+
 // Max height for sending multiple blocks when connecting the Bitcoin mainnet.
 const MAINNET_MAX_MULTI_BLOCK_ANCHOR_HEIGHT: BlockHeight = 750_000;
 
@@ -108,6 +121,7 @@ impl GetSuccessorsHandler {
                 &request.anchor,
                 &request.processed_block_hashes,
                 allow_multiple_blocks,
+                self.network,
             );
             let next = get_next_headers(
                 &state,
@@ -151,6 +165,7 @@ fn get_successor_blocks(
     anchor: &BlockHash,
     processed_block_hashes: &[BlockHash],
     allow_multiple_blocks: bool,
+    network: Network,
 ) -> Vec<Arc<Block>> {
     let seen: HashSet<BlockHash> = processed_block_hashes.iter().copied().collect();
 
@@ -162,6 +177,11 @@ fn get_successor_blocks(
         .map(|c| c.children.iter().collect())
         .unwrap_or_default();
 
+    let max_blocks_size = match network {
+        Network::Testnet4 => TESTNET4_MAX_BLOCKS_BYTES,
+        _ => MAX_BLOCKS_BYTES,
+    };
+
     // Compute the blocks by starting a breadth-first search.
     while let Some(block_hash) = queue.pop_front() {
         if !seen.contains(block_hash) {
@@ -170,7 +190,7 @@ fn get_successor_blocks(
                 Some(block) => {
                     let block_size = block.total_size();
                     if response_block_size == 0
-                        || (response_block_size + block_size <= MAX_BLOCKS_BYTES
+                        || (response_block_size + block_size <= max_blocks_size
                             && successor_blocks.len() < MAX_BLOCKS_LENGTH
                             && allow_multiple_blocks)
                     {
@@ -780,9 +800,4 @@ mod test {
             u32::MAX
         );
     }
-
-    #[test]
-    fn response_size() {
-        assert_eq!(MAX_NEXT_BYTES + MAX_BLOCKS_BYTES, MAX_RESPONSE_SIZE);
-    }
 }