Struct PendingAck 

pub struct PendingAck<const FRAME: usize = MAX_RESEND_FRAME_LEN> {
    pub ack_trailer: [u8; 8],
    pub peer: PublicKey,
    pub resend: ResendRecord<FRAME>,
    pub sent_ms: u64,
    pub ack_deadline_ms: u64,
    pub retries: u8,
    pub state: AckState,
    pub completion: CompletionSignal,
    pub confirm_key: Option<DupCacheKey>,
}

Complete tracking state for one in-flight tracked transmission.

The coordinator’s IdentitySlot maintains a LinearMap of PendingAck records keyed by SendReceipt, one per active tracked send — every ACK-requested send, plus every non-ACK unicast or blind unicast that travels through repeaters and therefore retries until a repeat is heard (CompletionSignal). The record holds everything needed to detect completion, detect timeout, and retransmit:

• ack_trailer — the 8-byte ack_mic || ack_tag value that will appear as the destination’s MAC ACK trailer. The ack_mic half correlates the ack to this request; the keyed ack_tag half can only be produced by a node that received and successfully decrypted the original frame, so a matching trailer is cryptographic proof of delivery.
• peer — the destination’s full public key, used to look up the correct pending entry when matching an inbound MAC ACK against the pending table.
• resend — a verbatim copy of the sealed frame for retransmission. See ResendRecord.
• sent_ms — the monotonic millisecond timestamp at which the frame was first transmitted; useful for latency measurement.
• ack_deadline_ms — absolute deadline for the final ACK. Expiry means failure and the entry is removed.
• retries — the number of retransmissions already attempted; capped at MAX_FORWARD_RETRIES.
• state — current position in the AckState lifecycle (forwarding confirmation wait or final-ACK wait).

Use PendingAck::direct for sends to nodes in direct radio range, PendingAck::forwarded when routing through a repeater, or PendingAck::repeat_only for a non-ACK send that completes on an overheard repeat.

Fields

ack_trailer: [u8; 8]

Expected 8-byte MAC ack trailer (ack_mic || ack_tag) used for inbound matching. Never matched for CompletionSignal::RepeatOnly entries.

peer: PublicKey

Final destination peer.

resend: ResendRecord<FRAME>

Retransmission data.

sent_ms: u64

Initial send timestamp in milliseconds.

ack_deadline_ms: u64

Absolute deadline for the final ACK — or, for a CompletionSignal::RepeatOnly entry, the terminal deadline after which the entry is silently discarded.

retries: u8

Number of retries already attempted.

state: AckState

Current state in the ACK lifecycle.

completion: CompletionSignal

Which observation completes this send.

confirm_key: Option<DupCacheKey>

Routing identity of the transmitted frame, recorded at transmit time so an overheard repeat can be matched against this entry even after the post-transmit listen window has lapsed.

Implementations

impl<const FRAME: usize> PendingAck<FRAME>

pub fn direct( ack_trailer: [u8; 8], peer: PublicKey, resend: ResendRecord<FRAME>, ) -> Self

Create pending-ACK state for a direct send.

pub fn forwarded( ack_trailer: [u8; 8], peer: PublicKey, resend: ResendRecord<FRAME>, ) -> Self

Create pending-ACK state for a forwarded send.

pub fn repeat_only(peer: PublicKey, resend: ResendRecord<FRAME>) -> Self

Create tracking state for a non-ACK send that completes when a repeat of the frame is overheard.

pub fn expects_ack(&self) -> bool

Whether a transport ACK is expected for this entry.

Trait Implementations

impl<const FRAME: usize> Clone for PendingAck<FRAME>

fn clone(&self) -> PendingAck<FRAME>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const FRAME: usize> Debug for PendingAck<FRAME>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const FRAME: usize> PartialEq for PendingAck<FRAME>

fn eq(&self, other: &PendingAck<FRAME>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const FRAME: usize> Eq for PendingAck<FRAME>

impl<const FRAME: usize> StructuralPartialEq for PendingAck<FRAME>