Struct GenericIpNodeID 

pub struct GenericIpNodeID<A: NodeIpAddress> {
    pub node_id: Vec<u8>,
    pub ip_addr: A,
    pub public_key: Vec<u8>,
    pub signature: Vec<u8>,
    pub timestamp_secs: u64,
    pub salt: Vec<u8>,
}

Generic IP-based node identity that binds node ID to network location

This struct provides a unified implementation for both IPv4 and IPv6 node identities, reducing code duplication while maintaining type safety.

Fields

node_id: Vec<u8>

Derived node ID (SHA256 of ip_addr + public_key + salt + timestamp)

ip_addr: A

IP address this node ID is bound to

public_key: Vec<u8>

ML-DSA public key for signatures

signature: Vec<u8>

Signature proving ownership of the IP address and keys

timestamp_secs: u64

Timestamp when this ID was generated (seconds since epoch)

salt: Vec<u8>

Salt used in node ID generation (for freshness)

Implementations

impl<A: NodeIpAddress> GenericIpNodeID<A>

pub fn generate( ip_addr: A, secret: &MlDsaSecretKey, public: &MlDsaPublicKey, ) -> Result<Self>

Generate a new IP-based node ID

pub fn verify(&self) -> Result<bool>

Verify that this node ID is valid and properly signed

pub fn age_secs(&self) -> u64

Get the age of this node ID in seconds

pub fn is_expired(&self, max_age: Duration) -> bool

Check if the node ID has expired (older than max_age)

Trait Implementations

impl<A: Clone + NodeIpAddress> Clone for GenericIpNodeID<A>

fn clone(&self) -> GenericIpNodeID<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + NodeIpAddress> Debug for GenericIpNodeID<A>

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

Formats the value using the given formatter.

impl<'de, A> Deserialize<'de> for GenericIpNodeID<A>

where A: Deserialize<'de> + NodeIpAddress,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A> Serialize for GenericIpNodeID<A>

where A: Serialize + NodeIpAddress,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.