util: write JSON atomically in WriteJson #35763

pull kevkevinpal wants to merge 2 commits into bitcoin:master from kevkevinpal:banlist-atomic-write-json-unsafe changing 6 files +66 −17
  1. kevkevinpal commented at 12:47 PM on July 21, 2026: contributor

    Summary

    Follow-up to #35384 (comment)

    • Renamed common::WriteSettings to common::WriteJson.
    • WriteJson writes to path + ".tmp" and RenameOver()s into place, so a failed or interrupted write cannot leave a truncated destination. Both settings.json and banlist.json use this helper.
    • Added a unit test for the write/read roundtrip, that the .tmp is gone after success, that rename failure is detected, and that a second failed write overwrites the same .tmp rather than creating another.
  2. DrahtBot added the label Utils/log/libs on Jul 21, 2026
  3. DrahtBot commented at 12:47 PM on July 21, 2026: contributor

    <!--e57a25ab6845829454e8d69fc972939a-->

    The following sections might be updated with supplementary metadata relevant to reviewers and maintainers.

    <!--006a51241073e994b41acfe9ec718e94-->

    External sites

    <!--021abf342d371248e50ceaed478a90ca-->

    Reviews

    See the guideline and AI policy for information on the review process.

    Type Reviewers
    ACK winterrdog, ryanofsky
    Stale ACK Herb-ops

    If your review is incorrectly listed, please copy-paste <code>&lt;!--meta-tag:bot-skip--&gt;</code> into the comment that the bot should ignore.

    <!--174a7506f384e20aa4161008e828411d-->

    Conflicts

    Reviewers, this pull request conflicts with the following ones:

    • #34520 <sub><img src="https://drahtbot.space/ack_count/bitcoin/bitcoin/34520.svg"></sub> (refactor: Add [[nodiscard]] to functions returning bool+mutable ref by maflcko)

    If you consider this pull request important, please also help to review the conflicting pull requests. Ideally, start with the one that should be merged first.

    <!--5faf32d7da4f0f540f40219e4f7537a3-->

  4. winterrdog commented at 5:42 PM on July 21, 2026: contributor

    Concept ACK

    Thanks for picking these up.

    cc: @sys-dev @ryanofsky

  5. Herb-ops commented at 11:52 AM on July 28, 2026: none

    ACK 07ec5af152b5bcff1b74decb9c7b729dff6c2283, with two non-blocking observations:

    The test is useful, but it also passes when CBanDB::Write is changed back to direct writing. Negative control proved this. It therefore does not verify the rename behavior named by the test.

    The generalized WriteJsonUnsafe helper still reports “settings file” errors when writing banlist.json.tmp. “JSON file” or “file” would be accurate for both callers.

  6. winterrdog commented at 10:14 PM on July 28, 2026: contributor

    The test is useful, but it also passes when CBanDB::Write is changed back to direct writing. Negative control proved this. It therefore does not verify the rename behavior named by the test.

    The generalized WriteJsonUnsafe helper still reports “settings file” errors when writing banlist.json.tmp. “JSON file” or “file” would be accurate for both callers.

    these need attention. so, i think they are blocking

  7. winterrdog commented at 10:36 PM on July 28, 2026: contributor

    while going through this, another thought came to mind. right now WriteJsonUnsafe writes directly to whatever path it is given and relies on the caller to do the tmp-file + RenameOver() step. both current callers (args.cpp and addrdb.cpp) do this correctly, but that guarantee only lives in a comment. nothing stops a future caller from accidentally writing straight to a live file

    i was wondering if it is worth making this a bit harder to misuse. two possible approaches came to mind

    <details><summary><b>approach A: add <code>WriteJsonAtomic</code> alongside <code>WriteJsonUnsafe</code></b></summary>

    keep the low-level helper as-is, but add a wrapper that handles the tmp-file + rename step:

    // settings.h
    bool WriteJsonUnsafe(const fs::path& path,
                         const std::map<std::string, SettingsValue>& values,
                         std::vector<std::string>& errors);
    
    bool WriteJsonAtomic(const fs::path& dest_path,
                         const std::map<std::string, SettingsValue>& values,
                         std::vector<std::string>& errors);
    
    
    // settings.cpp
    bool WriteJsonAtomic(const fs::path& dest_path,
                         const std::map<std::string, SettingsValue>& values,
                         std::vector<std::string>& errors)
    {
        const fs::path path_tmp{dest_path + ".tmp"};
        if (!WriteJsonUnsafe(path_tmp, values, errors)) {
            return false;
        }
        return RenameOver(path_tmp, dest_path);
    }
    

    callers become:

    // either this
    if (!WriteJsonUnsafe(path_tmp, values, errors)) return false;
    if (!RenameOver(path_tmp, path)) return false;
    
    // or this
    if (!WriteJsonAtomic(path, values, errors)) return false;
    

    this keeps the current API intact while giving callers a safe helper for the common case. existing callers with custom tmp-file handling can keep using WriteJsonUnsafe, while new callers can just use WriteJsonAtomic. the downside is that the footgun is still there. WriteJsonUnsafe is still publicly available, so a future caller can still accidentally bypass the atomic write path. it also means carrying two helpers that are closely related

    </details>

    <details><summary><b>approach B: make the helper always write atomically</b></summary>

    this is quite similar to the idea @sys-dev suggested here.

    instead of exposing both APIs, make the helper always write to a tmp file and rename it:

    // settings.h
    bool WriteJson(const fs::path& dest_path,
                   const std::map<std::string, SettingsValue>& values,
                   std::vector<std::string>& errors);
    
    // settings.cpp
    bool WriteJson(const fs::path& dest_path,
                   const std::map<std::string, SettingsValue>& values,
                   std::vector<std::string>& errors)
    {
        SettingsValue out(SettingsValue::VOBJ);
        for (const auto& [key, value] : values) out.pushKVEnd(key, value);
    
        const fs::path path_tmp{dest_path + ".tmp"};
    
        std::ofstream file{path_tmp.std_path()};
        // ...error handling lives here...
        file << out.write(/*prettyIndent=*/4, /*indentLevel=*/1) << std::endl;
    
        return RenameOver(path_tmp, dest_path);
    }
    

    this makes the safe path the only path. every caller gets atomic writes by default, so it is no longer possible to accidentally write directly to a live file. the tradeoff is that every caller now gets .tmp + RenameOver() semantics, even if a future use case genuinely just wants "write these bytes to this exact path" (for example, a one-off dump or export). it also bakes the tmp-file naming scheme into the helper itself

    </details>


    my thinking: i lean toward approach B unless there is already a use case for exposing the raw write helper. it feels a bit simpler, and it removes the footgun instead of just documenting it. that said, i could easily be missing a future use case where writing directly to the given path is the better choice

    any thoughts ?

  8. kevkevinpal force-pushed on Aug 2, 2026
  9. kevkevinpal force-pushed on Sep 7, 2026
  10. kevkevinpal commented at 2:26 PM on September 7, 2026: contributor

    @Herb-ops @winterrdog, can you review this again?

  11. winterrdog commented at 7:18 PM on September 7, 2026: contributor

    approach ACK


    now, we can update the PR title & description to match what the current code actually does. they still mention WriteJsonUnsafe and callers doing the atomic rename, while the current implementation is self-contained and handles the "temp write + RenameOver()" itself

  12. in src/common/settings.cpp:156 in 0e67947755 outdated
     155 | +        return false;
     156 | +    }
     157 | +    if (!RenameOver(path_tmp, path)) {
     158 | +        errors.emplace_back(strprintf("Failed renaming JSON file %s to %s", fs::PathToString(path_tmp), fs::PathToString(path)));
     159 |          return false;
     160 |      }
    


    winterrdog commented at 7:21 PM on September 7, 2026:

    premise: cleaning up path_tmp in case one of the error paths is explored

    currently, WriteJson() returns false but leaves the .tmp file behind. the new test (write_uses_rename) actually has to manually remove banlist_atomic.json.tmp after exercising the error paths, so it looks like we can leave stale temp files around in cases like persistent permission problems, an antivirus file lock on Windows, or repeated rename failures, these temp files are most likely to accumulate indefinitely

    would a best-effort fs::remove(path_tmp) on the failure path make sense here, or do you prefer leaving the temp file around?

    if implemented, one of the tradeoffs i can easily think of is the loss of forensic evidence when debugging persistent failures.

    any thoughts ?


    kevkevinpal commented at 9:25 PM on September 7, 2026:

    I prefer leaving it.

    The tmp name is stable (path + ".tmp"), so a later attempt opens the same file and overwrites it. You get at most one leftover per destination, not an accumulating set. That matches the old settings.json write, which also left the .tmp on rename failure.

    The fs::remove(...tmp) in the test is just fixture cleanup.


    I can amend the commit to add a test that asserts we don't create endless tmp files



    winterrdog commented at 6:37 PM on September 8, 2026:

    The tmp name is stable (path + ".tmp"), so a later attempt opens the same file and overwrites it.

    makes sense. i concur

    let me know if this looks good to you

    yes! good, it is

  13. kevkevinpal renamed this:
    util: atomically write banlist.json and rename WriteSettings to WriteJsonUnsafe
    util: write JSON atomically in WriteJson
    on Sep 7, 2026
  14. kevkevinpal force-pushed on Sep 7, 2026
  15. in src/common/settings.cpp:125 in 0260a681e1
     120 | @@ -119,7 +121,7 @@ bool ReadSettings(const fs::path& path, std::map<std::string, SettingsValue>& va
     121 |      return errors.empty();
     122 |  }
     123 |  
     124 | -bool WriteSettings(const fs::path& path,
     125 | +bool WriteJson(const fs::path& path,
     126 |      const std::map<std::string, SettingsValue>& values,
    


    winterrdog commented at 6:33 PM on September 8, 2026:

    :( this has dragged on for quite some time. the approach and code work fine but i spotted an API naming issue that i think is worth discussing.

    currently, WriteSettings was renamed to WriteJson, but ReadSettings kept its old name. so we now have a WriteJson / ReadSettings pair that operates on the same kind of data, but has different names (asymmetry)

    so, i see 3 potential directions:

    A. keep the ReadSettings / WriteSettings pair

    probably the simplest fix for this PR. these functions are not really generic JSON helpers anyway: they assume a flat map<string, SettingsValue> and handle the _warning_ key. the downside is that having WriteSettings write to something like banlist.json feels a little odd

    B. rename both to a ReadJson / WriteJson pair

    this fixes the asymmetry with a small change. the downside is that WriteJson sounds more generic than it actually is, because it would still have settings-specific behavior like adding the _warning_ key.

    C. extract the generic JSON functionality from the settings functionality into separate functions

    for example, have generic ReadJsonFile / WriteJsonFile helpers underneath, then keep ReadSettings / WriteSettings as thin wrappers for the settings-specific behavior.

    this seems like the cleanest long-term design if we expect more JSON-backed files to use this code, but probably more work than this PR expected.


    any thoughts on this ?


    kevkevinpal commented at 10:12 PM on September 10, 2026:

    Thank you for the review, and yeah, I agree that it's strange to have them different like that. I pushed ed55f14 to do path A.

    We can do a follow-up for C if we want after this is merged.


    winterrdog commented at 5:15 PM on September 17, 2026:

    do a follow-up for C if we want

    that is fine. we can do that

  16. kevkevinpal force-pushed on Sep 10, 2026
  17. DrahtBot added the label CI failed on Sep 10, 2026
  18. DrahtBot removed the label CI failed on Sep 17, 2026
  19. winterrdog commented at 5:23 PM on September 17, 2026: contributor

    tACK ed55f14404baabc9eaff68d25e50e167a2fafc8f

    successfully built and tested on FreeBSD 15.0/clang++-19.1.7/x86_64. the changes herein LGTM as well

  20. sedited requested review from ryanofsky on Nov 4, 2026
  21. in src/common/settings.h:53 in ed55f14404 outdated
      49 | +//! Atomically write a settings file.
      50 | +//!
      51 | +//! Writes to a temporary `.tmp` file next to `path`, then uses RenameOver()
      52 | +//! to replace the destination. This avoids leaving a truncated or empty file
      53 | +//! if the write is interrupted.
      54 |  bool WriteSettings(const fs::path& path,
    


    ryanofsky commented at 6:20 PM on November 5, 2026:

    In commit "util: atomically write banlist.json and settings.json" (ed55f14404baabc9eaff68d25e50e167a2fafc8f)

    The commit message should say what behavior changes. It is only a title now, and since the commit also moves code around (the .tmp handling moves from WriteSettingsFile into WriteSettings, GetSettingsPath loses its temp parameter, CBanDB::Write is restructured), the diff makes it hard to see what the actual change is: banlist.json used to be written in place and is now written through a temporary file, while settings.json is written the same way as before. I'd suggest something like:

    util: write banlist.json through a temporary file
    
    Before this change, CBanDB::Write() passed banlist.json directly to
    common::WriteSettings(), which truncates the file and then writes it.
    If the node crashed during the write, or the write failed because the
    disk was full, banlist.json could be left empty or partly written. On
    the next startup the ban list would fail to load and all bans would be
    dropped.
    
    settings.json did not have this problem, because
    ArgsManager::WriteSettingsFile() wrote settings.json.tmp and renamed it
    over settings.json.
    
    Move the .tmp file and RenameOver() step from WriteSettingsFile() into
    WriteSettings(), so banlist.json is written the same way. If writing
    banlist.json fails now, the previous banlist.json is kept and
    banlist.json.tmp is left behind, to be overwritten by the next write.
    
    settings.json is written the same way as before. The only change there
    is the wording of write errors, which now say "JSON file" instead of
    "settings file".
    

    It would be even easier to review as two commits: first a small commit that changes CBanDB::Write to write banlist.json.tmp and call RenameOver itself, with the new test, so the behavior change is a few lines on its own; then a refactoring commit that moves the .tmp handling into WriteSettings and removes it from both callers, with no behavior change other than the error wording.

    The PR title and description also still say WriteJson, and they go into the merge commit, so they should be updated to match too.


    kevkevinpal commented at 5:45 PM on November 12, 2026:

    Thanks, this is now addressed in 4a0f4916f60d31ec38afea3c141e7c8f53ffa46b


    ryanofsky commented at 12:03 PM on November 13, 2026:

    re: #35763 (review)

    The PR title and description also still say WriteJson, and they go into the merge commit, so they should be updated to match too.

    Thanks, the two commits are easier to review now. The PR title and description still describe the earlier version though (WriteJson, renaming WriteSettings).

  22. in src/common/settings.h:52 in ed55f14404
      44 | @@ -45,7 +45,11 @@ bool ReadSettings(const fs::path& path,
      45 |      std::map<std::string, SettingsValue>& values,
      46 |      std::vector<std::string>& errors);
      47 |  
      48 | -//! Write settings file.
      49 | +//! Atomically write a settings file.
      50 | +//!
      51 | +//! Writes to a temporary `.tmp` file next to `path`, then uses RenameOver()
      52 | +//! to replace the destination. This avoids leaving a truncated or empty file
      53 | +//! if the write is interrupted.
    


    ryanofsky commented at 6:20 PM on November 5, 2026:

    In commit "util: atomically write banlist.json and settings.json" (ed55f14404baabc9eaff68d25e50e167a2fafc8f)

    Non-blocking: this protects against the process being killed or failing partway through the write, but since nothing calls fsync before the rename, a power loss can still leave an empty file on some filesystems (SerializeFileDB in addrdb.cpp calls Commit() before renaming for that reason). Not something this PR needs to fix, but the comment could be more specific so callers don't assume more:

    //! Write a settings file by writing to a temporary `.tmp` file next to `path`
    //! and using RenameOver() to replace the destination. This avoids leaving a
    //! truncated or empty file if the process is interrupted while writing. The
    //! file is not synced to disk, so this does not protect against power loss.
    

    kevkevinpal commented at 5:45 PM on November 12, 2026:

    Thanks, this is now addressed in 9f2077dc09c98e093e15c605ef292669ef409f1d

  23. in src/addrdb.cpp:151 in ed55f14404
     153 | +            LogError("%s\n", err);
     154 | +        }
     155 | +        return false;
     156 |      }
     157 | -    return false;
     158 | +    return true;
    


    ryanofsky commented at 6:20 PM on November 5, 2026:

    In commit "util: atomically write banlist.json and settings.json" (ed55f14404baabc9eaff68d25e50e167a2fafc8f)

    Nit: now that the function is called WriteSettings again, this function's behavior doesn't change, so the restructuring here could be dropped to keep the diff to the files that actually change. Fine either way.


    kevkevinpal commented at 5:45 PM on November 12, 2026:

    Thanks, this is now addressed in 9f2077dc09c98e093e15c605ef292669ef409f1d

  24. in src/test/banman_tests.cpp:76 in ed55f14404
      71 | +        BOOST_CHECK(!bandb.Write(bans_write));
      72 | +        BOOST_CHECK(!bandb.Write(bans_write));
      73 | +        BOOST_CHECK(fs::exists(banlist_path + ".json.tmp"));
      74 | +        int tmp_count{0};
      75 | +        for (const auto& entry : fs::directory_iterator(banlist_path.parent_path())) {
      76 | +            const std::string name{fs::PathToString(entry.path().filename())};
    


    ryanofsky commented at 6:20 PM on November 5, 2026:

    In commit "util: atomically write banlist.json and settings.json" (ed55f14404baabc9eaff68d25e50e167a2fafc8f)

    Nit: entry here shadows the CBanEntry entry declared at the top of the test, which made this a little confusing to read.

            for (const auto& dir_entry : fs::directory_iterator(banlist_path.parent_path())) {
                const std::string name{fs::PathToString(dir_entry.path().filename())};
    

    kevkevinpal commented at 5:45 PM on November 12, 2026:

    Thanks, this is now addressed in 4a0f4916f60d31ec38afea3c141e7c8f53ffa46b

  25. in src/common/settings.cpp:136 in ed55f14404 outdated
     132 | @@ -132,20 +133,25 @@ bool WriteSettings(const fs::path& path,
     133 |      for (const auto& value : values) {
     134 |          out.pushKVEnd(value.first, value.second);
     135 |      }
     136 | +    const fs::path path_tmp{path + ".tmp"};
    


    ryanofsky commented at 6:35 PM on November 5, 2026:

    In commit "util: atomically write banlist.json and settings.json" (ed55f14404baabc9eaff68d25e50e167a2fafc8f)

    This ended up different from what I suggested in #35384 (comment), and from an earlier version of this PR: keep WriteSettings a low-level function that writes the path it is given, rename it to make clear it is unsafe to use without RenameOver, and have callers do the rename. I still slightly prefer that, because I like functions that do one thing well, and once a write function also manages the temporary file it has to make choices for every caller (how the temporary file is named, whether to fsync) that some callers might want to make differently. But I don't see a problem with the current approach, and it is simpler for the two callers that exist now, so please go with whichever makes more sense to you.


    ryanofsky commented at 1:08 PM on November 13, 2026:

    re: #35763 (review)

    once a write function also manages the temporary file it has to make choices for every caller

    A small example of this is error messages. Because WriteSettings is now shared by two kinds of files, this PR changes its errors from "settings file" to "JSON file", which is less clear for settings.json. ReadSettings has the opposite problem: its parse error talks about a settings file and says removing it "will reset settings to default values", which is wrong for banlist.json (https://github.com/bitcoin/bitcoin/pull/35763#discussion_r4563647011). This PR doesn't change ReadSettings, so it doesn't make that harder to fix, but in both cases the caller is what knows which file it is (CBanDB::Read already adds "Cannot load banlist" to the message) and what happens if it is removed. I think messages are easier to get right if low-level functions just read and write JSON and callers add the context as I originally suggested #35384 (comment). Still not a blocker for me.

  26. ryanofsky approved
  27. ryanofsky commented at 6:38 PM on November 5, 2026: contributor

    Code review ACK ed55f14404baabc9eaff68d25e50e167a2fafc8f. Thanks for following up on #35384 and for the test of the rename failure path.

  28. sedited commented at 1:20 PM on November 12, 2026: contributor

    @kevkevinpal do you want to take ryanofsky's suggestions?

  29. kevkevinpal commented at 2:01 PM on November 12, 2026: contributor

    ryanofsky

    Yes, this completely slipped my mind. Will address it right now

  30. util: write banlist.json through a temporary file
    Before this change, CBanDB::Write() passed banlist.json directly to
    common::WriteSettings(), which truncates the file and then writes it.
    If the node crashed during the write, or the write failed because the
    disk was full, banlist.json could be left empty or partly written. On
    the next startup the ban list would fail to load and all bans would be
    dropped.
    
    settings.json did not have this problem, because
    ArgsManager::WriteSettingsFile() writes settings.json.tmp and renames
    it over settings.json.
    
    Write banlist.json the same way: write banlist.json.tmp and use
    RenameOver() to replace banlist.json. If writing banlist.json fails
    now, the previous banlist.json is kept and banlist.json.tmp is left
    behind, to be overwritten by the next write.
    4a0f4916f6
  31. refactor: move .tmp handling into common::WriteSettings
    Both callers of common::WriteSettings(), ArgsManager::WriteSettingsFile()
    for settings.json and CBanDB::Write() for banlist.json, now write a .tmp
    file and use RenameOver() to replace the destination. Move that step
    into WriteSettings() itself, remove it from both callers, and drop the
    now unused temp parameter of ArgsManager::GetSettingsPath().
    
    There is no behavior change, except that write errors for settings.json
    now say "JSON file" instead of "settings file".
    9f2077dc09
  32. kevkevinpal force-pushed on Nov 12, 2026
  33. winterrdog commented at 10:25 PM on November 12, 2026: contributor

    reACK 9f2077dc09c98e093e15c605ef292669ef409f1d

    successfully built and tested on FreeBSD 15.0/clang++-19.1.7/x86_64.

    generally, the new changes bring in more clarity which is good for future maintenance

  34. DrahtBot requested review from ryanofsky on Nov 12, 2026
  35. in src/common/settings.cpp:91 in 9f2077dc09


    ryanofsky commented at 1:09 PM on November 13, 2026:

    In commit "refactor: move .tmp handling into common::WriteSettings" (9f2077dc09c98e093e15c605ef292669ef409f1d)

    Note: not for this PR, but a possible follow-up. The PR makes a truncated banlist.json less likely, but the way the truncated file is handled still seems unsafe to me. A truncated settings.json fails to parse and is reported as an error at startup. A truncated banlist.json fails to parse the same way, but CBanDB::Read only logs a warning, and BanMan::LoadBanlist resets to an empty banlist, which the BanMan constructor immediately writes over the corrupt file. So the bans are lost, and the file that would show what happened is gone.

  36. in src/addrdb.cpp:157 in 4a0f4916f6
     158 | +        LogError("Failed renaming JSON file %s to %s\n", fs::PathToString(banlist_tmp), fs::PathToString(m_banlist_json));
     159 | +        return false;
     160 |      }
     161 | -    return false;
     162 | +    return true;
     163 |  }
    


    ryanofsky commented at 1:19 PM on November 13, 2026:

    In commit "util: write banlist.json through a temporary file" (4a0f4916f60d31ec38afea3c141e7c8f53ffa46b)

    The second commit reverts the changes this commit makes to CBanDB::Write, so across the PR addrdb.cpp doesn't change at all. That would seem more reasonable if the change being reverted were minimal, but this commit also restructures the function to return early on failure instead of on success, which the fix doesn't need.

    Ideally I'd like to see (1) this commit reduced to a minimal bugfix without the restructuring, something like:

     bool CBanDB::Write(const banmap_t& banSet)
     {
    +    const fs::path banlist_tmp{m_banlist_json + ".tmp"};
         std::vector<std::string> errors;
    -    if (common::WriteSettings(m_banlist_json, {{JSON_KEY, BanMapToJson(banSet)}}, errors)) {
    -        return true;
    +    if (common::WriteSettings(banlist_tmp, {{JSON_KEY, BanMapToJson(banSet)}}, errors)) {
    +        if (RenameOver(banlist_tmp, m_banlist_json)) return true;
    +        errors.emplace_back(strprintf("Failed renaming JSON file %s to %s", fs::PathToString(banlist_tmp), fs::PathToString(m_banlist_json)));
         }
    

    and (2) the second commit dropped, which would also match the design I'd prefer (https://github.com/bitcoin/bitcoin/pull/35763#discussion_r4563641406). But I'm also happy to see this merged as-is, or in any other form that fixes the bug.

  37. ryanofsky approved
  38. ryanofsky commented at 1:37 PM on November 13, 2026: contributor

    Code review ACK 9f2077dc09c98e093e15c605ef292669ef409f1d. banlist.json is now written through a temporary file and RenameOver(), like settings.json, so a crash or full disk during the write can no longer leave it truncated.

    Thanks for the updates and the clear commit messages. Remaining comments are minor and can be ignored: the PR title and description still describe the earlier WriteJson version (https://github.com/bitcoin/bitcoin/pull/35763#discussion_r4563027281), the commits could be simpler, with a minimal fix in the first commit and no second commit (https://github.com/bitcoin/bitcoin/pull/35763#discussion_r4563653108), and there is a possible follow-up about how a corrupt banlist.json is handled (https://github.com/bitcoin/bitcoin/pull/35763#discussion_r4563647011).


github-metadata-mirror

This is a metadata mirror of the GitHub repository bitcoin/bitcoin. This site is not affiliated with GitHub. Content is generated from a GitHub metadata backup.
generated: 2026-11-18 04:51 UTC

This site is hosted by @0xB10C
More mirrored repositories can be found on mirror.b10c.me