Struct AnnounceData 

pub struct AnnounceData {
    pub public_key: [u8; 64],
    pub name_hash: [u8; 10],
    pub random_hash: [u8; 10],
    pub ratchet: Option<[u8; 32]>,
    pub signature: [u8; 64],
    pub app_data: Option<Vec<u8>>,
}

Parsed announce data.

Layout without ratchet:

[public_key:64][name_hash:10][random_hash:10][signature:64][app_data:*]

Layout with ratchet (context_flag == FLAG_SET):

[public_key:64][name_hash:10][random_hash:10][ratchet:32][signature:64][app_data:*]

Fields

public_key: [u8; 64]

name_hash: [u8; 10]

random_hash: [u8; 10]

ratchet: Option<[u8; 32]>

signature: [u8; 64]

app_data: Option<Vec<u8>>

Implementations

impl AnnounceData

pub fn pack( identity: &Identity, destination_hash: &[u8; 16], name_hash: &[u8; 10], random_hash: &[u8; 10], ratchet: Option<&[u8; 32]>, app_data: Option<&[u8]>, ) -> Result<(Vec<u8>, bool), AnnounceError>

Pack announce fields into bytes, signing with the provided identity.

Returns (announce_data_bytes, has_ratchet).

pub fn unpack(data: &[u8], has_ratchet: bool) -> Result<Self, AnnounceError>

Parse announce bytes into structured data.

has_ratchet corresponds to context_flag == FLAG_SET.

pub fn signature_cache_key(&self, destination_hash: &[u8; 16]) -> [u8; 32]

Key for the announce signature cache: SHA-256 over the signed data followed by the signature.

Two announces share a key only when every signed field and the signature are identical, so a cached verification result applies to exactly the announce it was computed for.

pub fn validate( &self, destination_hash: &[u8; 16], ) -> Result<ValidatedAnnounce, AnnounceError>

Validate an announce: verify signature and check destination hash.

Follows Python Identity.validate_announce():

1. Create Identity from public_key
2. Build signed_data = destination_hash + public_key + name_hash + random_hash + ratchet + app_data
3. Verify signature over signed_data
4. Compute identity_hash = truncated_hash(public_key)
5. expected_hash = truncated_hash(name_hash || identity_hash)
6. Verify expected_hash == destination_hash

pub fn to_validated_with_cached_signature( &self, destination_hash: &[u8; 16], ) -> Result<ValidatedAnnounce, AnnounceError>

Build a ValidatedAnnounce for an announce whose signature cache key (see Self::signature_cache_key) is already in the signature cache.

The signature was verified for an identical announce earlier; the structural checks are repeated here: the identity hash is recomputed from public_key and the destination hash binding is checked. The public key decoded successfully when that earlier announce was verified, since the cache key covers the key bytes.

Trait Implementations

impl Clone for AnnounceData

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AnnounceData

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

Formats the value using the given formatter.