The specified git tag v0.38.0 for cpp-httplib does not appear to exist in the official yhirose/cpp-httplib repository. The latest version seems to follow a v0.major.minor scheme (e.g., v0.15.3). This could be a typo and might cause build failures for users who do not have this specific commit cached. Please verify the tag and use a valid, existing tag to ensure build reproducibility.

The seed corpus for fuzz_block_header is outdated. The block header size has been increased to 112 bytes, but this seed is still 100 bytes long (200 hex characters). This will cause the fuzzer to start with an invalid input. The seed should be updated to be 112 bytes (224 hex characters) to match the new header size.

Critical: submitheader and submitblock RPCs are broken — external mining is impossible

Both RPCs enforce exactly 224 hex chars (112 bytes = bare header with no payload). However, CheckBlockHeader now requires vPayload.size() >= 32. Any block submitted via these RPCs will have an empty vPayload and fail validation with "bad-payload-size".

Additionally, getblocktemplate does not return payload_root, reward_token_id, or UTB data, so external miners have no way to construct valid blocks even if the size check were fixed.

Suggestion: Accept variable-length hex input (minimum 224 chars for the header + at least 64 chars for the 32-byte token ID hash):

if (hex.size() < 288) {  // 112-byte header + 32-byte minimum payload
    return util::JsonError("Invalid block data (minimum 288 hex chars: 112-byte header + 32-byte payload)");
}

And update getblocktemplate to return the payload fields.

Critical: No maximum payload size — resource exhaustion vector

There is a minimum (32 bytes) but no maximum. An attacker can craft blocks with multi-megabyte payloads that pass payloadRoot verification (they control both leaves). Every node stores vPayload in the in-memory CBlockIndex permanently.

Suggestion:

if (header.vPayload.size() < 32) {
    return state.Invalid("bad-payload-size", "block payload missing Token ID hash");
}
static constexpr size_t MAX_PAYLOAD_SIZE = 4096;  // 32 bytes token hash + UTB CBOR
if (header.vPayload.size() > MAX_PAYLOAD_SIZE) {
    return state.Invalid("bad-payload-size", "block payload exceeds maximum size");
}

Critical: quorum_threshold == 0 allows empty signatures to pass

At line 231, return total_stake >= trusted->quorum_threshold returns true with zero valid signatures if quorum_threshold is 0. Combined with IsValid() only checking epoch == 1 for genesis (no validation of threshold or root_nodes), an attacker-crafted trust base with threshold 0 and no signers passes all checks.

Suggestion: Add guards here at the top of IsValid():

bool RootTrustBaseV1::IsValid(const RootTrustBaseV1* prev) const {
  // Universal validity checks
  if (quorum_threshold == 0) return false;
  if (root_nodes.empty()) return false;
  ...

Critical: getrandom() is not available on macOS — build will fail

getrandom(2) is a Linux-specific syscall. The #else branch catches all non-Windows platforms, including macOS which the project explicitly supports (CMakeLists.txt, CI). The comment says "Linux: getrandom(2)" but the code path runs on macOS too.

Suggestion: Add macOS support:

#if defined(__APPLE__)
    // macOS: arc4random_buf has no failure mode
    arc4random_buf(data, len);
    return;
#else
    // Linux: getrandom(2)
    const ssize_t ret = getrandom(data + offset, len - offset, 0);
    ...
#endif

Or use getentropy() which works on both (limited to 256 bytes per call).

High: Wire format is backward-incompatible with no protocol version negotiation

The HEADERS message changed from fixed-size 100-byte entries to length-prefixed variable-size entries. Old and new nodes cannot communicate. There is no version bump or feature bit to detect incompatible peers — they will fail with opaque deserialization errors.

Consider bumping the protocol version and rejecting peers with incompatible versions during the version handshake.

Low: Unused include

<iostream> is not used in this file. Likely a debugging leftover — remove it.

Low: Duplicate CBOR tag prepending in SigBytes() and ToCBOR()

The 0xd9 0x03 0xf5 tag-prepending logic is duplicated between here (lines 139-145) and ToCBOR() (lines 155-161). Extract a helper:

static std::vector<uint8_t> PrependCBORTag1013(std::vector<uint8_t> data) {
    data.insert(data.begin(), {0xd9, 0x03, 0xf5});
    return data;
}

Low: SigBytes() deep-copies entire struct just to clear signatures

This copies all vectors, maps, and node lists. You can avoid the copy:

// Instead of copying the whole struct:
nlohmann::json j;
to_json(j, *this);
j[9] = nullptr;  // Override signatures to null
// Then serialize j directly

Low: Redundant latest_trust_base_ alongside sorted trust_bases_ map

Since trust_bases_ is a std::map<uint64_t, ...> (sorted by epoch), the latest is always trust_bases_.rbegin()->second. Storing a separate copy doubles memory and risks the two getting out of sync.

Consider:

const RootTrustBaseV1* GetLatestLocked() const {
    return trust_bases_.empty() ? nullptr : &trust_bases_.rbegin()->second;
}

Low: Inconsistent error handling — ProcessTrustBase mixes nullopt and exceptions

Returns std::nullopt for "already have this epoch" (line 100) but throws std::invalid_argument for validation failures (lines 105, 109). SyncTrustBases catches exceptions and returns {}, making it impossible for callers to distinguish "no new trust bases" from "sync failed due to malicious data".

Consider a consistent pattern — either return error codes for all failures, or make SyncTrustBases propagate errors instead of swallowing them.