Struct SubtreeByteChallenge 

pub struct SubtreeByteChallenge {
    pub challenge_id: u64,
    pub nonce: [u8; 32],
    pub challenged_peer_id: [u8; 32],
    pub expected_commitment_hash: [u8; 32],
    pub keys: Vec<XorName>,
}

Round 2 of the storage audit (ADR-0002): the surprise byte challenge.

After the auditor has structurally verified a SubtreeAuditResponse::Proof it picks a small sample of that subtree’s just-proven leaves with FRESH randomness (chosen now, after the proof is committed — NOT derived from the round-1 nonce, so the responder could not have predicted it at proof-build time) and asks the responder to return the ORIGINAL chunk bytes for exactly those keys. The auditor then checks each returned chunk against the committed leaf:

• BLAKE3(bytes) == leaf.bytes_hash (the chunk’s content address), AND
• compute_audit_digest(nonce, peer, key, bytes) == leaf.nonced_hash.

This makes possession non-delegable to the auditor: the auditor needs to hold NONE of the responder’s chunks. A responder that committed to a chunk it no longer holds cannot fabricate bytes that hash to the committed address (a preimage break), so it is caught regardless of who audits it.

Fields

challenge_id: u64

The same challenge_id as the round-1 SubtreeAuditChallenge, so the responder/auditor correlate the two rounds.

nonce: [u8; 32]

The same nonce as round 1 — needed for the freshness (nonced_hash) check and to bind these bytes to this audit.

challenged_peer_id: [u8; 32]

The challenged peer ID (bound into each leaf’s possession hash).

expected_commitment_hash: [u8; 32]

The pinned commitment hash from round 1, so the responder resolves the SAME tree it just proved and serves bytes only for keys it committed to.

keys: Vec<XorName>

The exact keys whose original bytes the responder must return. These are the auditor’s freshly-randomised spot-check sample of the round-1 subtree (chosen after the proof was received; not nonce-derived).

Trait Implementations

impl Clone for SubtreeByteChallenge

fn clone(&self) -> SubtreeByteChallenge

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SubtreeByteChallenge

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SubtreeByteChallenge

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SubtreeByteChallenge

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.