Struct InterestBuilder 

pub struct InterestBuilder { /* private fields */ }

Configurable Interest encoder.

let wire = InterestBuilder::new("/ndn/test")
    .lifetime(Duration::from_millis(2000))
    .must_be_fresh()
    .build();

Implementations

impl InterestBuilder

pub fn new(name: impl Into<Name>) -> InterestBuilder

pub fn lifetime(self, d: Duration) -> InterestBuilder

pub fn can_be_prefix(self) -> InterestBuilder

pub fn must_be_fresh(self) -> InterestBuilder

pub fn hop_limit(self, h: u8) -> InterestBuilder

pub fn app_parameters(self, p: impl Into<Vec<u8>>) -> InterestBuilder

pub fn forwarding_hint(self, names: Vec<Name>) -> InterestBuilder

pub fn build_with_timeout(self) -> (Bytes, Duration)

Build the Interest wire and return a suitable local receive timeout.

The timeout is the Interest lifetime plus a 500 ms forwarding buffer. Use this with Consumer::fetch_with so you don’t have to compute the timeout manually:

use ndn_packet::encode::InterestBuilder;
let data = consumer.fetch_with(
    InterestBuilder::new("/ndn/test")
        .hop_limit(4)
        .forwarding_hint(vec!["/hint/hub".parse()?])
        .app_parameters(b"q=hello"),
).await?;

pub fn build(self) -> Bytes

pub async fn sign<F, Fut>( self, sig_type: SignatureType, key_locator: Option<&Name>, sign_fn: F, ) -> Bytes

where F: FnOnce(&[u8]) -> Fut, Fut: Future<Output = Bytes>,

Encode and sign the Interest packet (Signed Interest per NDN v0.3 §5.4).

sig_type and key_locator describe the signature algorithm and optional KeyLocator name for InterestSignatureInfo. sign_fn receives the signed region (Name through InterestSignatureInfo) and returns the raw signature bytes.

If app_parameters was not set, an empty ApplicationParameters TLV is used — signed Interests must carry ApplicationParameters per spec.

Anti-replay fields (SignatureNonce, SignatureTime, SignatureSeqNum) are included in InterestSignatureInfo if set via the builder. If none are set, a random 8-byte SignatureNonce and the current wall-clock SignatureTime are generated automatically.

pub fn sign_digest_sha256(self) -> Bytes

Sign with DigestSha256 — SHA-256 of the signed region.

This is the minimum signature type accepted by NFD for management Interests on the loopback face. No key material is required; NFD verifies the signature by recomputing the SHA-256 itself.

Use this when sending management commands (rib/register, etc.) to NFD or ndnd so they do not silently drop the Interest.

pub fn sign_sync<F>( self, sig_type: SignatureType, key_locator: Option<&Name>, sign_fn: F, ) -> Bytes

where F: FnOnce(&[u8]) -> Bytes,

Synchronous encode-and-sign for CPU-only signers (Ed25519, HMAC).

Trait Implementations

impl SignWith for InterestBuilder

fn sign_with_sync( self, signer: &(dyn Signer + 'static), ) -> Result<Bytes, TrustError>

Sign this packet using the given signer (synchronous).