The Moment of Selection: Timestamps and the Internal Constructor

[!NOTE] Technical Context: private_broadcast.h | Lines 134-140

In lines 134 through 140 of private_broadcast.h, we conclude the definition of the SendStatus internal structure. This block introduces the temporal "Record of Selection" and the formal constructor that initializes this vital unit of state. This is the "Birth Certificate" of a private broadcast attempt.

1. const NodeClock::time_point picked: The Immutable Birth

Line 134 defines the picked timestamp as a const.

As we have seen in previous articles, picked is the moment the PickTxForSend() method (Part 012) decided that this specific transaction should be sent to this specific peer. By making this timestamp const, the architect is ensuring that the "History" of the broadcast cannot be rewritten.

The Integrity of the Timeout Calculation

The STALE_DURATION (1 minute) is calculated by comparing the current time to this picked time. If picked could be changed (mutated) after the object was created, the node could accidentally "Reset" its own timers, leading to a transaction that stays in the "Stale" state forever. By locking the timestamp at the moment of birth, the module guarantees that its timeout logic is mathematically sound and immune to accidental interference.

2. std::optional<NodeClock::time_point> confirmed: The Goal of the Mission

Line 136 defines the confirmed member.

Unlike the other members, this is Not const. It is an std::optional that starts as nullopt and is eventually updated with a timestamp when the PONG message arrives (Part 014).

This is the "Destination" of the entire state machine. The transition of this variable from nullopt to a time_point is the "Success Signal" that allows the transaction to be removed from the queue. By using optional, the code remains expressive: if confirmed has a value, the mission is accomplished. If it doesn't, the node is still in the "Vigilance" phase.

3. The SendStatus Constructor: The Formal Initialization

Lines 138-139 provide the constructor for the struct:

Copy

SendStatus(const NodeId& nodeid, const CService& address, const NodeClock::time_point& picked) 
 : nodeid{nodeid}, address{address}, picked{picked} {}

This is a Member Initializer List. In C++, this is the most efficient way to initialize constant members.

By requiring all three pieces of data (nodeid, address, and picked) at the moment of creation, the constructor ensures that a "Half-Baked" SendStatus object can never exist. You cannot have a status without a peer, and you cannot have a status without a timestamp. This is "Compile-Time Enforcement" of logical consistency.

4. The Architecture of Precision

The use of the curly braces {} (Uniform Initialization) for the members is a modern C++11 feature. It prevents "Narrowing Conversions" (e.g., accidentally passing a 64-bit integer into a 32-bit field), adding another layer of type-safety to the protocol's heart.

Every character in this constructor is optimized for Safety and Speed. It represents the "High-Performance" engineering standards of the Bitcoin Core project, where even the creation of a small internal object is handled with the same rigor as the validation of a block.

5. Architectural Synthesis: The Micro-State

The SendStatus struct is a "Micro-State" manager. It doesn't know about the global network; it only knows about a single transaction's relationship with a single peer.

By building the larger PrivateBroadcast system out of these small, immutable, and type-safe units, the architect is creating a "Fractal Design." Each small part is perfect and easy to test, which makes the massive 690,000-line whole more robust. This is the secret to Bitcoin's decade of 99.99% uptime: a system built on millions of tiny, unbreakable contracts like the ones defined in these seven lines.

Conclusion: The End of the Second Batch

We have now completed the first 20 articles of the Bitcoin Core Architectural Encyclopedia. We have seen the public interface, the legal guardrails, the data structures, and now the internal "Birth Certificate" of a network broadcast.

In the next batch (0021-0030), we will examine the TxBroadcastInfo implementation and finally reveal the std::unordered_map that serves as the "Master Brain" of the entire private broadcast system.