Merge #18877: Serve cfcheckpt requests

23083856a551ca13e8b142791c296ecb25cc4e7f [test] Add test for cfcheckpt (Jim Posen)
f9e00bb25ac4039056808affeb5ffa86a2c317fe [net processing] Message handling for getcfcheckpt. (Jim Posen)
9ccaaba11e94571fe984857494042ac292c17156 [init] Add -peerblockfilters option (Jim Posen)

Pull request description:

  Serve cfcheckpt messages if basic block filter index is enabled and `-peercfilters` is set.

  `NODE_COMPACT_FILTERS` is not signaled to peers, but functionality can be used for testing and serving pre-configured clients.

ACKs for top commit:
  jonatack:
    Code review re-ACK 23083856a551ca13e8b142791c296ecb25cc4e7f the only change since my review @ 967e2b1 is an update required for #16224 that was merged yesterday.
  fjahr:
    re-ACK 23083856a551ca13e8b142791c296ecb25cc4e7f
  jkczyz:
    re-ACK 23083856a551ca13e8b142791c296ecb25cc4e7f
  ariard:
    re-Code Review ACK 2308385
  clarkmoody:
    Tested ACK 23083856a
  MarcoFalke:
    re-ACK 23083856a5 🌳
  theStack:
    ACK https://github.com/bitcoin/bitcoin/commit/23083856a551ca13e8b142791c296ecb25cc4e7f

Tree-SHA512: 8c751bbd7d1c31a413096462ae025c3d2f3163c7016cbec472a5f5ec267f8dd19a2dfc4d749876d7409c1db546e6fdd16461c6863effcfa0d3e993edcfa92a08

4 files changed, 187 insertions, 0 deletions

diff --git a/test/functional/p2p_blockfilters.py b/test/functional/p2p_blockfilters.py
new file mode 100755
index 0000000000..4d00a6dc07
--- /dev/null
+++ b/test/functional/p2p_blockfilters.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+# Copyright (c) 2019 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Tests NODE_COMPACT_FILTERS (BIP 157/158).
+
+Tests that a node configured with -blockfilterindex and -peerblockfilters can serve
+cfcheckpts.
+"""
+
+from test_framework.messages import (
+    FILTER_TYPE_BASIC,
+    msg_getcfcheckpt,
+)
+from test_framework.mininode import P2PInterface
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    connect_nodes,
+    disconnect_nodes,
+    wait_until,
+)
+
+class CompactFiltersTest(BitcoinTestFramework):
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.rpc_timeout = 480
+        self.num_nodes = 2
+        self.extra_args = [
+            ["-blockfilterindex", "-peerblockfilters"],
+            ["-blockfilterindex"],
+        ]
+
+    def run_test(self):
+        # Node 0 supports COMPACT_FILTERS, node 1 does not.
+        node0 = self.nodes[0].add_p2p_connection(P2PInterface())
+        node1 = self.nodes[1].add_p2p_connection(P2PInterface())
+
+        # Nodes 0 & 1 share the same first 999 blocks in the chain.
+        self.nodes[0].generate(999)
+        self.sync_blocks(timeout=600)
+
+        # Stale blocks by disconnecting nodes 0 & 1, mining, then reconnecting
+        disconnect_nodes(self.nodes[0], 1)
+
+        self.nodes[0].generate(1)
+        wait_until(lambda: self.nodes[0].getblockcount() == 1000)
+        stale_block_hash = self.nodes[0].getblockhash(1000)
+
+        self.nodes[1].generate(1001)
+        wait_until(lambda: self.nodes[1].getblockcount() == 2000)
+
+        self.log.info("get cfcheckpt on chain to be re-orged out.")
+        request = msg_getcfcheckpt(
+            filter_type=FILTER_TYPE_BASIC,
+            stop_hash=int(stale_block_hash, 16)
+        )
+        node0.send_and_ping(message=request)
+        response = node0.last_message['cfcheckpt']
+        assert_equal(response.filter_type, request.filter_type)
+        assert_equal(response.stop_hash, request.stop_hash)
+        assert_equal(len(response.headers), 1)
+
+        self.log.info("Reorg node 0 to a new chain.")
+        connect_nodes(self.nodes[0], 1)
+        self.sync_blocks(timeout=600)
+
+        main_block_hash = self.nodes[0].getblockhash(1000)
+        assert main_block_hash != stale_block_hash, "node 0 chain did not reorganize"
+
+        self.log.info("Check that peers can fetch cfcheckpt on active chain.")
+        tip_hash = self.nodes[0].getbestblockhash()
+        request = msg_getcfcheckpt(
+            filter_type=FILTER_TYPE_BASIC,
+            stop_hash=int(tip_hash, 16)
+        )
+        node0.send_and_ping(request)
+        response = node0.last_message['cfcheckpt']
+        assert_equal(response.filter_type, request.filter_type)
+        assert_equal(response.stop_hash, request.stop_hash)
+
+        main_cfcheckpt = self.nodes[0].getblockfilter(main_block_hash, 'basic')['header']
+        tip_cfcheckpt = self.nodes[0].getblockfilter(tip_hash, 'basic')['header']
+        assert_equal(
+            response.headers,
+            [int(header, 16) for header in (main_cfcheckpt, tip_cfcheckpt)]
+        )
+
+        self.log.info("Check that peers can fetch cfcheckpt on stale chain.")
+        request = msg_getcfcheckpt(
+            filter_type=FILTER_TYPE_BASIC,
+            stop_hash=int(stale_block_hash, 16)
+        )
+        node0.send_and_ping(request)
+        response = node0.last_message['cfcheckpt']
+
+        stale_cfcheckpt = self.nodes[0].getblockfilter(stale_block_hash, 'basic')['header']
+        assert_equal(
+            response.headers,
+            [int(header, 16) for header in (stale_cfcheckpt,)]
+        )
+
+        self.log.info("Requests to node 1 without NODE_COMPACT_FILTERS results in disconnection.")
+        requests = [
+            msg_getcfcheckpt(
+                filter_type=FILTER_TYPE_BASIC,
+                stop_hash=int(main_block_hash, 16)
+            ),
+        ]
+        for request in requests:
+            node1 = self.nodes[1].add_p2p_connection(P2PInterface())
+            node1.send_message(request)
+            node1.wait_for_disconnect()
+
+        self.log.info("Check that invalid requests result in disconnection.")
+        requests = [
+            # Requesting unknown filter type results in disconnection.
+            msg_getcfcheckpt(
+                filter_type=255,
+                stop_hash=int(main_block_hash, 16)
+            ),
+            # Requesting unknown hash results in disconnection.
+            msg_getcfcheckpt(
+                filter_type=FILTER_TYPE_BASIC,
+                stop_hash=123456789,
+            ),
+        ]
+        for request in requests:
+            node0 = self.nodes[0].add_p2p_connection(P2PInterface())
+            node0.send_message(request)
+            node0.wait_for_disconnect()
+
+if __name__ == '__main__':
+    CompactFiltersTest().main()
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index 4855f62a8f..ef5ef49eaf 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -57,6 +57,8 @@ MSG_FILTERED_BLOCK = 3
 MSG_WITNESS_FLAG = 1 << 30
 MSG_TYPE_MASK = 0xffffffff >> 2
 
+FILTER_TYPE_BASIC = 0
+
 # Serialization/deserialization tools
 def sha256(s):
     return hashlib.new('sha256', s).digest()
@@ -1512,3 +1514,50 @@ class msg_no_witness_blocktxn(msg_blocktxn):
 
     def serialize(self):
         return self.block_transactions.serialize(with_witness=False)
+
+class msg_getcfcheckpt:
+    __slots__ = ("filter_type", "stop_hash")
+    msgtype =  b"getcfcheckpt"
+
+    def __init__(self, filter_type, stop_hash):
+        self.filter_type = filter_type
+        self.stop_hash = stop_hash
+
+    def deserialize(self, f):
+        self.filter_type = struct.unpack("<B", f.read(1))[0]
+        self.stop_hash = deser_uint256(f)
+
+    def serialize(self):
+        r = b""
+        r += struct.pack("<B", self.filter_type)
+        r += ser_uint256(self.stop_hash)
+        return r
+
+    def __repr__(self):
+        return "msg_getcfcheckpt(filter_type={:#x}, stop_hash={:x})".format(
+            self.filter_type, self.stop_hash)
+
+class msg_cfcheckpt:
+    __slots__ = ("filter_type", "stop_hash", "headers")
+    msgtype =  b"cfcheckpt"
+
+    def __init__(self, filter_type=None, stop_hash=None, headers=None):
+        self.filter_type = filter_type
+        self.stop_hash = stop_hash
+        self.headers = headers
+
+    def deserialize(self, f):
+        self.filter_type = struct.unpack("<B", f.read(1))[0]
+        self.stop_hash = deser_uint256(f)
+        self.headers = deser_uint256_vector(f)
+
+    def serialize(self):
+        r = b""
+        r += struct.pack("<B", self.filter_type)
+        r += ser_uint256(self.stop_hash)
+        r += ser_uint256_vector(self.headers)
+        return r
+
+    def __repr__(self):
+        return "msg_cfcheckpt(filter_type={:#x}, stop_hash={:x})".format(
+            self.filter_type, self.stop_hash)
diff --git a/test/functional/test_framework/mininode.py b/test/functional/test_framework/mininode.py
index 31cec66ee7..ba0391625e 100755
--- a/test/functional/test_framework/mininode.py
+++ b/test/functional/test_framework/mininode.py
@@ -31,6 +31,7 @@ from test_framework.messages import (
     msg_block,
     MSG_BLOCK,
     msg_blocktxn,
+    msg_cfcheckpt,
     msg_cmpctblock,
     msg_feefilter,
     msg_filteradd,
@@ -67,6 +68,7 @@ MESSAGEMAP = {
     b"addr": msg_addr,
     b"block": msg_block,
     b"blocktxn": msg_blocktxn,
+    b"cfcheckpt": msg_cfcheckpt,
     b"cmpctblock": msg_cmpctblock,
     b"feefilter": msg_feefilter,
     b"filteradd": msg_filteradd,
@@ -328,6 +330,7 @@ class P2PInterface(P2PConnection):
     def on_addr(self, message): pass
     def on_block(self, message): pass
     def on_blocktxn(self, message): pass
+    def on_cfcheckpt(self, message): pass
     def on_cmpctblock(self, message): pass
     def on_feefilter(self, message): pass
     def on_filteradd(self, message): pass
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 55c8c1d033..7821355e29 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -226,6 +226,7 @@ BASE_SCRIPTS = [
     'feature_loadblock.py',
     'p2p_dos_header_tree.py',
     'p2p_unrequested_blocks.py',
+    'p2p_blockfilters.py',
     'feature_includeconf.py',
     'feature_asmap.py',
     'mempool_unbroadcast.py',