Kernel: Remove BlockTreeEntry from the API

[janb84]

This PR replaces the btck_BlockTreeEntry type in the kernel C API with a single chain-oriented abstraction, btck_Chain, matching the end state described in https://purplekarrot.net/blog/drop-block-tree-entry-from-bitcoin-kernel.html.

Since a block uniquely determines its path to genesis, a chain is fully determined by its tip and shares the same underlying CBlockIndex. Consolidating on btck_Chain also better hides the kernel's internals, exposing an opaque chain handle rather than leaking the block-index structure into the API (leaving the kernel free to change that without breaking the C API).

New chain functions:

btck_chainstate_manager_get_active_chain / _get_best_chain / _find -> return chains
btck_chain_get_height
btck_chain_get_block_header / _get_block_hash / _get_ancestor
btck_chain_get_parent
btck_chain_starts_with / _find_fork / _equals

This design follows @purpleKarrot's writeup and parts of the approach are based on his blogpost ofc. happy to add a Co-authored-by: if he's comfortable with it (quality wise) .

[purpleKarrot]

Since the block can be retrieved from the chain tip, should block even be passed in the callback?
Also, I wonder why the block is mutable here. Is this callback supposed to be able to modify the block?

[purpleKarrot]

ChainView should inherit from std::ranges::view_interface<ChainView>.

[purpleKarrot]

mismatch should return std::ranges::mismatch_result.

[janb84]

Yes ok but performance, so what do you think about the compromise below. std::ranges::mismatch is O(n) this solution is O(log n) the 'compare' is walking from genesis to tip to find a mismatch (also side rant why from genesis ? such a deep reorg is unfeasible)

    std::optional<ChainView> FindFork(const ChainView& other) const
    {
        auto fork{btck_chain_find_fork(get(), other.get())};
        if (!fork) return std::nullopt;
        return ChainView{fork};
    }


    std::ranges::mismatch_result<std::optional<ChainView>, std::optional<ChainView>>
    Mismatch(const ChainView& other) const
    {
        auto fork{FindFork(other)};
        int32_t fork_height{fork ? fork->Height() : -1};
        std::optional<ChainView> in1{fork_height < Height() ? std::optional{GetAncestor(fork_height + 1)} : std::nullopt};
        std::optional<ChainView> in2{fork_height < other.Height() ? std::optional{other.GetAncestor(fork_height + 1)} : std::nullopt};
        return {in1, in2};
    }

(in this case btck_chain_mismatch() is renamed to btck_chain_find_fork() which also matches the result better)

[josibake]

Yes ok but performance

Knuth would like a word ;)

Take what I say with a grain of salt as I haven't dug into the code yet, but I am suspicious of performance if it sacrifices legibility and makes this hard to test. Even more suspicious if its not in a critical path (e.g., mining, IBD, block validation, etc).

[purpleKarrot]

What the mismatch member function does internally is an implementation detail and can be changed at any time. The only promise it should make is that it does produces the exact same outcome as std::ranges::mismatch but with a potentially better runtime complexity than $O(n)$.

There should be a test that covers this:

TEST_CASE("mismatch member matches standard free function")
{
  auto chain1 = ...;
  auto chain2 = ...;
  auto res1 = chain1.mismatch(chain2);
  auto res2 = std::ranges::mismatch(chain1, chain2);
  CHECK(std::same_as<decltype(res1), decltype(res2)>);
  CHECK(res1.in1 == res2.in1);
  CHECK(res1.in2 == res2.in2);
}

[josibake]

Concept ACK

Nice! I'll read the blog post before reviewing the implementation, but love to see it. This also seems like an excellent candidate to upstream.

[janb84]

Did a re-read of the blogpost and the comments here, that made me change the approach (a bit) to match the idea of the blogpost better.

Additionally:
ChainView -> Chain.
Removed the std::optional (from Find, Parent, FindFork and GetAncestor) ,by allowing the empty range / empty chain
Mismatch produces the exact same outcome as std::ranges::mismatch