Struct PointerState 

pub struct PointerState {
    pub state_id: XorName,
    pub address: XorName,
    pub counter: u64,
    pub target: PointerTarget,
}

The parts of a record that determine its authenticated state.

Parsed from the body alone, so obtaining one costs no signature verification. That is what lets a node recognise a re-submission of what it already holds and stop before doing expensive work.

Fields

state_id: XorName

The authenticated-state identifier, derived from the signed body.

address: XorName

The address the record belongs at.

counter: u64

The update counter, the merge rule’s first key.

target: PointerTarget

The target, whose bytes are the merge rule’s second key.

Implementations

impl PointerState

pub fn parse(bytes: &[u8]) -> Result<Self, PointerError>

Parse the state out of a record’s bytes without verifying its signature.

Checks length, format version and structure only. A PointerState says what a record claims; only Pointer::from_bytes establishes that the claim is signed.

Errors

Returns PointerError for a record of the wrong length, an unknown format version, or an unparseable owner key.

pub const fn is_terminal(&self) -> bool

Whether this state is final: signed at FINAL_COUNTER, and so replaced by nothing.

pub const fn transferred_to(&self) -> Option<XorName>

The pointer this state hands the address over to, if it is a transfer: a final state whose target is another pointer.

A final state targeting anything else freezes the pointer rather than handing it on, and a pointer target below the final counter is a forwarding the owner can still take back. Neither is a transfer.

pub fn replaces(&self, other: &Self) -> bool

Whether self replaces other under the merge rule.

0. a final state (counter == u64::MAX) is replaced by nothing
1. larger counter
2. smaller target bytes

Records of different owners are not comparable and neither replaces the other.

Equal state never replaces, whatever the signature bytes: ML-DSA signing is randomized, so one authenticated state has unboundedly many valid encodings, and ordering records by their bytes would let an owner sign one paid state repeatedly, sort worst-first and have every submission win — unbounded storage, replication and audit work for a single payment.

Rule 0 is what makes a pointer’s last state final, and so what makes ownership transferable by redirection (Pointer::transfer_to). Under rules 1 and 2 alone a state at the final counter could still be displaced by another at the same counter with smaller target bytes, so a former owner could grind a target and take the address back after handing it on.

The cost is that the order is total only below the final counter. Two different final states are incomparable: neither replaces the other, so whichever a node took first is the one it keeps. That is the only conflict this rule leaves unordered, and so the only fork no later state heals; a conflict at a lower counter is ordered by target bytes and replaced by any later counter. Only the owner can make it — by signing a second final state and getting it to nodes the first has not reached, at once or later. Once a node holds a final state no arrival can change it, so a second final state can never displace an established one; it can only land on a node that held no final state. A reader tells the two sides apart by how many of the close group hold each.

Every other pair of distinct states is ordered, and the order is a strict partial order everywhere: never both ways round, and transitive.

Trait Implementations

impl Clone for PointerState

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for PointerState

impl Debug for PointerState

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

Formats the value using the given formatter.

impl Eq for PointerState

impl PartialEq for PointerState

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PointerState