Merge bitcoin/bitcoin#22570: Ignore banlist.dat

fa1eddb1a3d1319ddc3643b6f34fe2014de32764 Fix whitespace in touched files (MarcoFalke)
fa4e6afdae7b82df638b60edf37ac36d57a8cb4f Remove unused CSubNet serialize code (MarcoFalke)
fa384fdd0b7af73d81fa9619c5fba779452cd2af Ignore banlist.dat (MarcoFalke)

Pull request description:

  The code to read `banlist.dat` should be removed eventually. The major release (22.x) can be used to translate a `banlist.dat` into a `banlist.json`. Thus, it is now possible to remove the reading code.

ACKs for top commit:
  Zero-1729:
    re-ACK fa1eddb1a3d1319ddc3643b6f34fe2014de32764
  laanwj:
    concept and code review ACK fa1eddb1a3d1319ddc3643b6f34fe2014de32764
  vasild:
    ACK fa1eddb1a3d1319ddc3643b6f34fe2014de32764
  jonatack:
    Light code review utACK fa1eddb1a3d1319ddc3643b6f34fe2014de32764

Tree-SHA512: e136193b7c0ba1d6d2e79c7fb4106ba4af75fa229ed7214675ee64e98e59bb4808779e7a8a09eecce62f7a5d4bc6e16b8a5ad4596129357c8fc5e3b88f214249

2 files changed, 135 insertions, 148 deletions

diff --git a/src/test/fuzz/banman.cpp b/src/test/fuzz/banman.cpp
index 1986b5e4c8..de211f601f 100644
--- a/src/test/fuzz/banman.cpp
+++ b/src/test/fuzz/banman.cpp
@@ -52,8 +52,7 @@ FUZZ_TARGET_INIT(banman, initialize_banman)
     const bool start_with_corrupted_banlist{fuzzed_data_provider.ConsumeBool()};
     bool force_read_and_write_to_err{false};
     if (start_with_corrupted_banlist) {
-        const std::string sfx{fuzzed_data_provider.ConsumeBool() ? ".dat" : ".json"};
-        assert(WriteBinaryFile(banlist_file.string() + sfx,
+        assert(WriteBinaryFile(banlist_file.string() + ".json",
                                fuzzed_data_provider.ConsumeRandomLengthString()));
     } else {
         force_read_and_write_to_err = fuzzed_data_provider.ConsumeBool();
@@ -114,6 +113,5 @@ FUZZ_TARGET_INIT(banman, initialize_banman)
             (void)(banmap == banmap_read);
         }
     }
-    fs::remove(banlist_file.string() + ".dat");
     fs::remove(banlist_file.string() + ".json");
 }
diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index 721e4360d0..d5b56cb7cd 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -100,228 +100,217 @@ void AssertEqualAfterSerializeDeserialize(const T& obj, const int version = INIT
 } // namespace
 
 FUZZ_TARGET_DESERIALIZE(block_filter_deserialize, {
-        BlockFilter block_filter;
-        DeserializeFromFuzzingInput(buffer, block_filter);
+    BlockFilter block_filter;
+    DeserializeFromFuzzingInput(buffer, block_filter);
 })
 FUZZ_TARGET_DESERIALIZE(addr_info_deserialize, {
-        CAddrInfo addr_info;
-        DeserializeFromFuzzingInput(buffer, addr_info);
+    CAddrInfo addr_info;
+    DeserializeFromFuzzingInput(buffer, addr_info);
 })
 FUZZ_TARGET_DESERIALIZE(block_file_info_deserialize, {
-        CBlockFileInfo block_file_info;
-        DeserializeFromFuzzingInput(buffer, block_file_info);
+    CBlockFileInfo block_file_info;
+    DeserializeFromFuzzingInput(buffer, block_file_info);
 })
 FUZZ_TARGET_DESERIALIZE(block_header_and_short_txids_deserialize, {
-        CBlockHeaderAndShortTxIDs block_header_and_short_txids;
-        DeserializeFromFuzzingInput(buffer, block_header_and_short_txids);
+    CBlockHeaderAndShortTxIDs block_header_and_short_txids;
+    DeserializeFromFuzzingInput(buffer, block_header_and_short_txids);
 })
 FUZZ_TARGET_DESERIALIZE(fee_rate_deserialize, {
-        CFeeRate fee_rate;
-        DeserializeFromFuzzingInput(buffer, fee_rate);
-        AssertEqualAfterSerializeDeserialize(fee_rate);
+    CFeeRate fee_rate;
+    DeserializeFromFuzzingInput(buffer, fee_rate);
+    AssertEqualAfterSerializeDeserialize(fee_rate);
 })
 FUZZ_TARGET_DESERIALIZE(merkle_block_deserialize, {
-        CMerkleBlock merkle_block;
-        DeserializeFromFuzzingInput(buffer, merkle_block);
+    CMerkleBlock merkle_block;
+    DeserializeFromFuzzingInput(buffer, merkle_block);
 })
 FUZZ_TARGET_DESERIALIZE(out_point_deserialize, {
-        COutPoint out_point;
-        DeserializeFromFuzzingInput(buffer, out_point);
-        AssertEqualAfterSerializeDeserialize(out_point);
+    COutPoint out_point;
+    DeserializeFromFuzzingInput(buffer, out_point);
+    AssertEqualAfterSerializeDeserialize(out_point);
 })
 FUZZ_TARGET_DESERIALIZE(partial_merkle_tree_deserialize, {
-        CPartialMerkleTree partial_merkle_tree;
-        DeserializeFromFuzzingInput(buffer, partial_merkle_tree);
+    CPartialMerkleTree partial_merkle_tree;
+    DeserializeFromFuzzingInput(buffer, partial_merkle_tree);
 })
 FUZZ_TARGET_DESERIALIZE(pub_key_deserialize, {
-        CPubKey pub_key;
-        DeserializeFromFuzzingInput(buffer, pub_key);
-        AssertEqualAfterSerializeDeserialize(pub_key);
+    CPubKey pub_key;
+    DeserializeFromFuzzingInput(buffer, pub_key);
+    AssertEqualAfterSerializeDeserialize(pub_key);
 })
 FUZZ_TARGET_DESERIALIZE(script_deserialize, {
-        CScript script;
-        DeserializeFromFuzzingInput(buffer, script);
-})
-FUZZ_TARGET_DESERIALIZE(sub_net_deserialize, {
-        CSubNet sub_net_1;
-        DeserializeFromFuzzingInput(buffer, sub_net_1, INIT_PROTO_VERSION);
-        AssertEqualAfterSerializeDeserialize(sub_net_1, INIT_PROTO_VERSION);
-        CSubNet sub_net_2;
-        DeserializeFromFuzzingInput(buffer, sub_net_2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
-        AssertEqualAfterSerializeDeserialize(sub_net_2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
-        CSubNet sub_net_3;
-        DeserializeFromFuzzingInput(buffer, sub_net_3);
-        AssertEqualAfterSerializeDeserialize(sub_net_3, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+    CScript script;
+    DeserializeFromFuzzingInput(buffer, script);
 })
 FUZZ_TARGET_DESERIALIZE(tx_in_deserialize, {
-        CTxIn tx_in;
-        DeserializeFromFuzzingInput(buffer, tx_in);
-        AssertEqualAfterSerializeDeserialize(tx_in);
+    CTxIn tx_in;
+    DeserializeFromFuzzingInput(buffer, tx_in);
+    AssertEqualAfterSerializeDeserialize(tx_in);
 })
 FUZZ_TARGET_DESERIALIZE(flat_file_pos_deserialize, {
-        FlatFilePos flat_file_pos;
-        DeserializeFromFuzzingInput(buffer, flat_file_pos);
-        AssertEqualAfterSerializeDeserialize(flat_file_pos);
+    FlatFilePos flat_file_pos;
+    DeserializeFromFuzzingInput(buffer, flat_file_pos);
+    AssertEqualAfterSerializeDeserialize(flat_file_pos);
 })
 FUZZ_TARGET_DESERIALIZE(key_origin_info_deserialize, {
-        KeyOriginInfo key_origin_info;
-        DeserializeFromFuzzingInput(buffer, key_origin_info);
-        AssertEqualAfterSerializeDeserialize(key_origin_info);
+    KeyOriginInfo key_origin_info;
+    DeserializeFromFuzzingInput(buffer, key_origin_info);
+    AssertEqualAfterSerializeDeserialize(key_origin_info);
 })
 FUZZ_TARGET_DESERIALIZE(partially_signed_transaction_deserialize, {
-        PartiallySignedTransaction partially_signed_transaction;
-        DeserializeFromFuzzingInput(buffer, partially_signed_transaction);
+    PartiallySignedTransaction partially_signed_transaction;
+    DeserializeFromFuzzingInput(buffer, partially_signed_transaction);
 })
 FUZZ_TARGET_DESERIALIZE(prefilled_transaction_deserialize, {
-        PrefilledTransaction prefilled_transaction;
-        DeserializeFromFuzzingInput(buffer, prefilled_transaction);
+    PrefilledTransaction prefilled_transaction;
+    DeserializeFromFuzzingInput(buffer, prefilled_transaction);
 })
 FUZZ_TARGET_DESERIALIZE(psbt_input_deserialize, {
-        PSBTInput psbt_input;
-        DeserializeFromFuzzingInput(buffer, psbt_input);
+    PSBTInput psbt_input;
+    DeserializeFromFuzzingInput(buffer, psbt_input);
 })
 FUZZ_TARGET_DESERIALIZE(psbt_output_deserialize, {
-        PSBTOutput psbt_output;
-        DeserializeFromFuzzingInput(buffer, psbt_output);
+    PSBTOutput psbt_output;
+    DeserializeFromFuzzingInput(buffer, psbt_output);
 })
 FUZZ_TARGET_DESERIALIZE(block_deserialize, {
-        CBlock block;
-        DeserializeFromFuzzingInput(buffer, block);
+    CBlock block;
+    DeserializeFromFuzzingInput(buffer, block);
 })
 FUZZ_TARGET_DESERIALIZE(blocklocator_deserialize, {
-        CBlockLocator bl;
-        DeserializeFromFuzzingInput(buffer, bl);
+    CBlockLocator bl;
+    DeserializeFromFuzzingInput(buffer, bl);
 })
 FUZZ_TARGET_DESERIALIZE(blockmerkleroot, {
-        CBlock block;
-        DeserializeFromFuzzingInput(buffer, block);
-        bool mutated;
-        BlockMerkleRoot(block, &mutated);
+    CBlock block;
+    DeserializeFromFuzzingInput(buffer, block);
+    bool mutated;
+    BlockMerkleRoot(block, &mutated);
 })
 FUZZ_TARGET_DESERIALIZE(addrman_deserialize, {
-        CAddrMan am;
-        DeserializeFromFuzzingInput(buffer, am);
+    CAddrMan am;
+    DeserializeFromFuzzingInput(buffer, am);
 })
 FUZZ_TARGET_DESERIALIZE(blockheader_deserialize, {
-        CBlockHeader bh;
-        DeserializeFromFuzzingInput(buffer, bh);
+    CBlockHeader bh;
+    DeserializeFromFuzzingInput(buffer, bh);
 })
 FUZZ_TARGET_DESERIALIZE(banentry_deserialize, {
-        CBanEntry be;
-        DeserializeFromFuzzingInput(buffer, be);
+    CBanEntry be;
+    DeserializeFromFuzzingInput(buffer, be);
 })
 FUZZ_TARGET_DESERIALIZE(txundo_deserialize, {
-        CTxUndo tu;
-        DeserializeFromFuzzingInput(buffer, tu);
+    CTxUndo tu;
+    DeserializeFromFuzzingInput(buffer, tu);
 })
 FUZZ_TARGET_DESERIALIZE(blockundo_deserialize, {
-        CBlockUndo bu;
-        DeserializeFromFuzzingInput(buffer, bu);
+    CBlockUndo bu;
+    DeserializeFromFuzzingInput(buffer, bu);
 })
 FUZZ_TARGET_DESERIALIZE(coins_deserialize, {
-        Coin coin;
-        DeserializeFromFuzzingInput(buffer, coin);
+    Coin coin;
+    DeserializeFromFuzzingInput(buffer, coin);
 })
 FUZZ_TARGET_DESERIALIZE(netaddr_deserialize, {
-        CNetAddr na;
-        DeserializeFromFuzzingInput(buffer, na);
-        if (na.IsAddrV1Compatible()) {
-            AssertEqualAfterSerializeDeserialize(na);
-        }
-        AssertEqualAfterSerializeDeserialize(na, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+    CNetAddr na;
+    DeserializeFromFuzzingInput(buffer, na);
+    if (na.IsAddrV1Compatible()) {
+        AssertEqualAfterSerializeDeserialize(na);
+    }
+    AssertEqualAfterSerializeDeserialize(na, INIT_PROTO_VERSION | ADDRV2_FORMAT);
 })
 FUZZ_TARGET_DESERIALIZE(service_deserialize, {
-        CService s;
-        DeserializeFromFuzzingInput(buffer, s);
-        if (s.IsAddrV1Compatible()) {
-            AssertEqualAfterSerializeDeserialize(s);
-        }
-        AssertEqualAfterSerializeDeserialize(s, INIT_PROTO_VERSION | ADDRV2_FORMAT);
-        CService s1;
-        DeserializeFromFuzzingInput(buffer, s1, INIT_PROTO_VERSION);
-        AssertEqualAfterSerializeDeserialize(s1, INIT_PROTO_VERSION);
-        assert(s1.IsAddrV1Compatible());
-        CService s2;
-        DeserializeFromFuzzingInput(buffer, s2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
-        AssertEqualAfterSerializeDeserialize(s2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+    CService s;
+    DeserializeFromFuzzingInput(buffer, s);
+    if (s.IsAddrV1Compatible()) {
+        AssertEqualAfterSerializeDeserialize(s);
+    }
+    AssertEqualAfterSerializeDeserialize(s, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+    CService s1;
+    DeserializeFromFuzzingInput(buffer, s1, INIT_PROTO_VERSION);
+    AssertEqualAfterSerializeDeserialize(s1, INIT_PROTO_VERSION);
+    assert(s1.IsAddrV1Compatible());
+    CService s2;
+    DeserializeFromFuzzingInput(buffer, s2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
+    AssertEqualAfterSerializeDeserialize(s2, INIT_PROTO_VERSION | ADDRV2_FORMAT);
 })
 FUZZ_TARGET_DESERIALIZE(messageheader_deserialize, {
-        CMessageHeader mh;
-        DeserializeFromFuzzingInput(buffer, mh);
-        (void)mh.IsCommandValid();
+    CMessageHeader mh;
+    DeserializeFromFuzzingInput(buffer, mh);
+    (void)mh.IsCommandValid();
 })
 FUZZ_TARGET_DESERIALIZE(address_deserialize_v1_notime, {
-        CAddress a;
-        DeserializeFromFuzzingInput(buffer, a, INIT_PROTO_VERSION);
-        // A CAddress without nTime (as is expected under INIT_PROTO_VERSION) will roundtrip
-        // in all 5 formats (with/without nTime, v1/v2, network/disk)
-        AssertEqualAfterSerializeDeserialize(a, INIT_PROTO_VERSION);
-        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
-        AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
-        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
-        AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
+    CAddress a;
+    DeserializeFromFuzzingInput(buffer, a, INIT_PROTO_VERSION);
+    // A CAddress without nTime (as is expected under INIT_PROTO_VERSION) will roundtrip
+    // in all 5 formats (with/without nTime, v1/v2, network/disk)
+    AssertEqualAfterSerializeDeserialize(a, INIT_PROTO_VERSION);
+    AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
+    AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
+    AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+    AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
 })
 FUZZ_TARGET_DESERIALIZE(address_deserialize_v1_withtime, {
-        CAddress a;
-        DeserializeFromFuzzingInput(buffer, a, PROTOCOL_VERSION);
-        // A CAddress in V1 mode will roundtrip in all 4 formats that have nTime.
-        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
-        AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
-        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
-        AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
+    CAddress a;
+    DeserializeFromFuzzingInput(buffer, a, PROTOCOL_VERSION);
+    // A CAddress in V1 mode will roundtrip in all 4 formats that have nTime.
+    AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
+    AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
+    AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+    AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
 })
 FUZZ_TARGET_DESERIALIZE(address_deserialize_v2, {
-        CAddress a;
-        DeserializeFromFuzzingInput(buffer, a, PROTOCOL_VERSION | ADDRV2_FORMAT);
-        // A CAddress in V2 mode will roundtrip in both V2 formats, and also in the V1 formats
-        // with time if it's V1 compatible.
-        if (a.IsAddrV1Compatible()) {
-            AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
-            AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
-        }
-        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
-        AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
+    CAddress a;
+    DeserializeFromFuzzingInput(buffer, a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+    // A CAddress in V2 mode will roundtrip in both V2 formats, and also in the V1 formats
+    // with time if it's V1 compatible.
+    if (a.IsAddrV1Compatible()) {
+        AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION);
+        AssertEqualAfterSerializeDeserialize(a, 0, SER_DISK);
+    }
+    AssertEqualAfterSerializeDeserialize(a, PROTOCOL_VERSION | ADDRV2_FORMAT);
+    AssertEqualAfterSerializeDeserialize(a, ADDRV2_FORMAT, SER_DISK);
 })
 FUZZ_TARGET_DESERIALIZE(inv_deserialize, {
-        CInv i;
-        DeserializeFromFuzzingInput(buffer, i);
+    CInv i;
+    DeserializeFromFuzzingInput(buffer, i);
 })
 FUZZ_TARGET_DESERIALIZE(bloomfilter_deserialize, {
-        CBloomFilter bf;
-        DeserializeFromFuzzingInput(buffer, bf);
+    CBloomFilter bf;
+    DeserializeFromFuzzingInput(buffer, bf);
 })
 FUZZ_TARGET_DESERIALIZE(diskblockindex_deserialize, {
-        CDiskBlockIndex dbi;
-        DeserializeFromFuzzingInput(buffer, dbi);
+    CDiskBlockIndex dbi;
+    DeserializeFromFuzzingInput(buffer, dbi);
 })
 FUZZ_TARGET_DESERIALIZE(txoutcompressor_deserialize, {
-        CTxOut to;
-        auto toc = Using<TxOutCompression>(to);
-        DeserializeFromFuzzingInput(buffer, toc);
+    CTxOut to;
+    auto toc = Using<TxOutCompression>(to);
+    DeserializeFromFuzzingInput(buffer, toc);
 })
 FUZZ_TARGET_DESERIALIZE(blocktransactions_deserialize, {
-        BlockTransactions bt;
-        DeserializeFromFuzzingInput(buffer, bt);
+    BlockTransactions bt;
+    DeserializeFromFuzzingInput(buffer, bt);
 })
 FUZZ_TARGET_DESERIALIZE(blocktransactionsrequest_deserialize, {
-        BlockTransactionsRequest btr;
-        DeserializeFromFuzzingInput(buffer, btr);
+    BlockTransactionsRequest btr;
+    DeserializeFromFuzzingInput(buffer, btr);
 })
 FUZZ_TARGET_DESERIALIZE(snapshotmetadata_deserialize, {
-        SnapshotMetadata snapshot_metadata;
-        DeserializeFromFuzzingInput(buffer, snapshot_metadata);
+    SnapshotMetadata snapshot_metadata;
+    DeserializeFromFuzzingInput(buffer, snapshot_metadata);
 })
 FUZZ_TARGET_DESERIALIZE(uint160_deserialize, {
-        uint160 u160;
-        DeserializeFromFuzzingInput(buffer, u160);
-        AssertEqualAfterSerializeDeserialize(u160);
+    uint160 u160;
+    DeserializeFromFuzzingInput(buffer, u160);
+    AssertEqualAfterSerializeDeserialize(u160);
 })
 FUZZ_TARGET_DESERIALIZE(uint256_deserialize, {
-        uint256 u256;
-        DeserializeFromFuzzingInput(buffer, u256);
-        AssertEqualAfterSerializeDeserialize(u256);
-})
-        // Classes intentionally not covered in this file since their deserialization code is
-        // fuzzed elsewhere:
-        // * Deserialization of CTxOut is fuzzed in test/fuzz/tx_out.cpp
-        // * Deserialization of CMutableTransaction is fuzzed in src/test/fuzz/transaction.cpp
+    uint256 u256;
+    DeserializeFromFuzzingInput(buffer, u256);
+    AssertEqualAfterSerializeDeserialize(u256);
+})
+// Classes intentionally not covered in this file since their deserialization code is
+// fuzzed elsewhere:
+// * Deserialization of CTxOut is fuzzed in test/fuzz/tx_out.cpp
+// * Deserialization of CMutableTransaction is fuzzed in src/test/fuzz/transaction.cpp