populate_with_metadata(const input&, bool) assertion

[evoskuil]

2026-05-08T01:52:06Z.0 Rpc response: (132) bytes [127.0.0.1:59852]
2026-05-08T01:52:06Z.0 Rpc request : (142) bytes [127.0.0.1:59852] blockchain.transaction.get(...).
2026-05-08T01:52:06Z.2 Inbound electrum channel stop [127.0.0.1:59852] missing parameter
2026-05-08T01:52:36Z.1 Outbound [174.165.64.87:8333] version (70016) /Satoshi:22.0.0/
2026-05-08T01:52:37Z.1 Outbound [84.197.51.49:8333] version (70016) /Satoshi:29.2.0/Knots:20251110/
2026-05-08T01:53:41Z.1 Advance by (50000) above (948387) from (948387) stop (998387) found (1) last (948388).
bsdbg: .../nix-gnu-debug-static/include/bitcoin/database/impl/query/consensus/consensus_populate.ipp:83: bool libbitcoin::database::query<Store>::populate_with_metadata(const input&, bool) const [with Store = libbitcoin::database::store<libbitcoin::database::map>; input = libbitcoin::system::chain::input]: Assertion `input.metadata.point_link == max_uint32' failed.
Aborted (core dumped)

[evoskuil]

This is most likely from the Electrum RPC request, despite the fact that there is a block arriving in short order. The block validates fine, and OTOH the Electrum validate_tx() method may not have been tested in debug builds. Given that the log shows a testing of successful Electrum transaction.get, I suspect the assertion is fired in a subsequent transaction.broadcast evaluation against the server, resulting in log termination before the async log system outputs the corresponding RPC request. It is a requirement of the population method that unpopulated inputs have properly defaulted input metadata. If in this code path the tx is not so populated, the assertion would fire:

Electrum transaction.broadcast in server:

    const auto tx = to_shared<chain::transaction>(tx_data, true);
    if (!tx->is_valid())
    {
        send_code(error::invalid_argument);
        return;
    }

    const auto fault = broadcast_tx(tx);

Population called here in server:

code protocol_electrum::validate_tx(
    const chain::transaction& tx) const NOEXCEPT
{
    chain::context ctx{};
    if (!get_pool_context(ctx))
        return error::server_error;

    code ec{};

    // Ensure tx does not violate tx consensus rules.
    if (!ec) ec = tx.check();
    if (!ec) ec = tx.check(ctx);
    if (!ec) archive().populate_with_metadata(tx, true);
    if (!ec) ec = tx.accept(ctx);
    if (!ec) ec = tx.confirm(ctx);
    if (!ec) ec = tx.connect(ctx);

    // Ensure tx does not violate presumed block consensus rules.
    // This is a DoS guard when validating a tx outside of a block.
    if (!ec) ec = tx.check_guard();
    if (!ec) ec = tx.check_guard(ctx);
    if (!ec) ec = tx.accept_guard(ctx);
    return ec;
}

code protocol_electrum::broadcast_tx(
    const chain::transaction::cptr& tx) NOEXCEPT
{
    if (const auto ec = validate_tx(*tx))
        return ec;

    BROADCAST(peer::transaction, to_shared<peer::transaction>(tx));
    return {};
}

Assertion here in database:

// populate_with_metadata
// ----------------------------------------------------------------------------
// These are used when performing confirmation, either directly (chain true) or
// caching metadata (chain false) in validation stage for later confirmation.

TEMPLATE
bool CLASS::populate_with_metadata(const block& block,
    bool chain) const NOEXCEPT
{
    const auto& txs = block.transactions_ptr();
    if (txs->empty())
        return false;

    return std::all_of(std::next(txs->begin()), txs->end(),
        [this, chain](const auto& tx) NOEXCEPT
        {
            return this->populate_with_metadata(*tx, chain);
        });
}

TEMPLATE
bool CLASS::populate_with_metadata(const transaction& tx,
    bool chain) const NOEXCEPT
{
    // This override makes the public method safe for coinbase calling.
    return tx.is_coinbase() || populate_with_metadata_(tx, chain);
}

// protected
TEMPLATE
bool CLASS::populate_with_metadata_(const transaction& tx,
    bool chain) const NOEXCEPT
{
    BC_ASSERT(!tx.is_coinbase());

    const auto& ins = tx.inputs_ptr();
    return std::all_of(ins->begin(), ins->end(),
        [this, chain](const auto& in) NOEXCEPT
        {
            return this->populate_with_metadata(*in, chain);
        });
}

TEMPLATE
bool CLASS::populate_with_metadata(const input& input,
    bool chain) const NOEXCEPT
{
    // Null point would return nullptr and be interpreted as missing.
    BC_ASSERT(!input.point().is_null());

    // input.metadata.point_link must be defaulted to max_uint32.
    BC_ASSERT(input.metadata.point_link == max_uint32);

    if (input.prevout)
        return true;

    const auto tx = to_tx(input.point().hash());
    const auto index = input.point().index();

    // Node and chain confirmation.
    input.prevout = get_output(tx, index);
    input.metadata.coinbase = is_coinbase(tx);

    // Node only (cheap so always include).
    input.metadata.parent_tx = tx;

    // This is used by node for unconfirmed tx validation (expensive).
    // There are three consensus-relevant heights. These are the height of the
    // presumed next block (pool), the height of the block containing previous
    // output's transaction, and the height of a block containing a previous
    // spender of the previous output. median-time-past is of the prevout.
    if (chain)
    {
        auto& metadata = input.metadata;

        context ctx{};
        if (get_context(ctx, find_strong(metadata.parent_tx)))
        {
            // Confirmed previous output found at height (and with mtp).
            metadata.prevout_height = ctx.height;
            metadata.median_time_past = ctx.mtp;
        }
        else
        {
            // Confirmed previous output not found.
            metadata.prevout_height = max_uint32;
            metadata.median_time_past = max_uint32;
        }

        if (const auto height = find_strong_spender_height(input.point());
            !height.is_terminal())
        {
            // Confirmed spender found at height.
            metadata.spender_height = system::possible_narrow_cast<uint32_t>(
                height.value);
        }
        else
        {
            // Confirmed spender not found.
            metadata.spender_height = max_uint32;
        }
    }

    // If read via the store for store confirmation, then...
    // input.metadata.point_link must be set earlier in get_input().
    ////BC_ASSERT(input.metadata.point_link != max_uint32);
    return !is_null(input.prevout);
}

[evoskuil]

system::chain::input.metadata is defined as mutable chain::prevout metadata{}; and that class defaults as:

class BC_API prevout final
{
public:
    /// chain/node: prevout is of a coinbase tx.
    bool coinbase{ true };

    /// chain: confirmed prevout mtp or max_uint32.
    uint32_t median_time_past{ max_uint32 };

    /// chain: confirmed prevout height or max_uint32.
    size_t prevout_height{ max_uint32 };

    /// chain: confirmed spender height or max_uint32.
    uint32_t spender_height{ max_uint32 };

    /// node: database identifier for the parent tx.
    /// Link::terminal must align with link defaults of max_uint32.
    uint32_t parent_tx{ max_uint32 };

    /// node: database identifier for input/point.
    /// Link::terminal must align with link defaults of max_uint32.
    uint32_t point_link{ max_uint32 };
};

There were some changes made here within the past couple of months. It appears the default is as intended/required.

[evoskuil]

Otherwise, if this is a consequence of block validation, this is the only other place in the entire server stack where this method is called (node):

void chaser_validate::validate_block(const header_link& link,
    bool bypass) NOEXCEPT
{
    if (closed())
        return;

    code ec{};
    chain::context ctx{};
    auto& query = archive();

    // TODO: implement allocator parameter resulting in full allocation to
    // shared_ptr<block>, to optimize deallocate (12% of milestone/filter).
    const auto block = query.get_block(link, node_witness_);

    if (!block)
    {
        ec = error::validate2;
    }
    else if (!query.get_context(ctx, link))
    {
        ec = error::validate3;
    }
    else if ((ec = populate(bypass, *block, ctx)))
    {
        if (!query.set_block_unconfirmable(link))
            ec = error::validate4;
    }
    else if ((ec = validate(bypass, *block, link, ctx)))
    {
        if (!query.set_block_unconfirmable(link))
            ec = error::validate5;
    }

    complete_block(ec, link, ctx.height, bypass);

    // Prevent stall by posting internal event, avoiding external handlers.
    if (is_one(backlog_.fetch_sub(one, std::memory_order_relaxed)))
        handle_event(error::success, chase::bump, height_t{});
}

code chaser_validate::populate(bool bypass, const chain::block& block,
    const chain::context& ctx) NOEXCEPT
{
    const auto& query = archive();

    if (bypass)
    {
        // Populating for filters only (no validation metadata required).
        block.populate(ctx);
        if (!query.populate_without_metadata(block))
            return system::error::missing_previous_output;
    }
    else
    {
        // Internal maturity and time locks are verified here because they are
        // the only necessary confirmation checks for internal spends.
        if (const auto ec = block.populate(ctx))
            return ec;

        // Metadata identifies internal spends allowing confirmation bypass.
        if (!query.populate_with_metadata(block))
            return system::error::missing_previous_output;
    }
    
    return error::success;
}

[evoskuil]

block::populate(ctx) does not populate metadata, metadata.point_link is only populated (non-default) from (database query for input/block/tx):

TEMPLATE
typename CLASS::input::cptr CLASS::get_input(const point_link& link,
    bool witness) const NOEXCEPT
{
    using namespace system;
    table::input::get_ptrs in{ {}, witness };
    table::ins::get_input ins{};
    table::point::record point{};
    if (!store_.ins.get(link, ins) ||
        !store_.point.get(link, point) ||
        !store_.input.get(ins.input_fk, in))
        return {};

    const auto ptr = to_shared<input>
    (
        make_point(std::move(point.hash), point.index),
        in.script,
        in.witness,
        ins.sequence
    );

    // Node only (cheap so always include).
    // Internally-populated points will have default link of max_uint32.
    ptr->metadata.point_link = link;
    return ptr;
}

[evoskuil]

It appears that during the aforementioned rework the assertion was commented out for this reason, but there was a artifact duplicate of it that was inadvertently left behind. I believe the reason it was present and then removed is because the order of population of the metadata was changed. It was simpler to just always populated it when querying for the input, which means that it is generally populated before this code, not after, making the assertion incorrect here.

TEMPLATE
bool CLASS::populate_with_metadata(const input& input,
    bool chain) const NOEXCEPT
{
    // Null point would return nullptr and be interpreted as missing.
    BC_ASSERT(!input.point().is_null());

    // input.metadata.point_link must be defaulted to max_uint32.
    BC_ASSERT(input.metadata.point_link == max_uint32);

...

    // If read via the store for store confirmation, then...
    // input.metadata.point_link must be set earlier in get_input().
    ////BC_ASSERT(input.metadata.point_link != max_uint32);
    return !is_null(input.prevout);
}

[evoskuil]

So it seems clear that this is just a case of a misplaced assertion that resulted from a recent change. The resolution is to remove the assertion. Also, this implies the failure resulted in the block validation, not the Electrum method. The reason it hasn't been encountered is that it's rare to run block validation in a full debug build and simply hadn't been done until now.

[evoskuil]

Assertion removed in PR #788