Struct InputPair 

pub struct InputPair<T, F1, F2> { /* private fields */ }

Pre-generated inputs for timing tests.

Both baseline() and sample() call their respective closures to generate values. This symmetric design ensures both classes have identical calling patterns.

Type Parameters

• T: The input type (e.g., [u8; 32], Vec<u8>)
• F1: The baseline closure type
• F2: The sample closure type

Example

use tacet::helpers::InputPair;

// Both are closures (symmetric)
let inputs = InputPair::new(
    || [0u8; 32],          // baseline closure
    || rand::random(),     // sample closure
);

// Use in test - both call their closures
let baseline_val = inputs.baseline();
let sample_val = inputs.sample();

Implementations

impl<T, F1, F2> InputPair<T, F1, F2>

where T: Clone + Hash, F1: FnMut() -> T, F2: FnMut() -> T,

pub fn new(baseline: F1, sample: F2) -> Self

Create a new input pair with anomaly detection.

Both arguments are closures that generate input values.

Arguments

• baseline: Closure that generates the baseline value (typically constant)
• sample: Closure that generates varied sample values

Type Requirements

• T: Clone for internal operations
• T: Hash for anomaly detection (use new_untracked for non-Hash types)

Example

let inputs = InputPair::new(
    || [0u8; 32],                // baseline: returns constant value
    || rand::random::<[u8; 32]>() // sample: generates varied values
);

pub fn new_unchecked(baseline: F1, sample: F2) -> Self

Create a new input pair without anomaly detection.

Use this when you intentionally use deterministic inputs (e.g., fixed nonces, pre-generated signatures) and want to suppress the “identical values” warning.

Example

// Testing with fixed nonces - intentionally deterministic
let nonces = InputPair::new_unchecked(
    || [0x00u8; 12],  // Fixed nonce A
    || [0xFFu8; 12],  // Fixed nonce B
);

pub fn baseline(&self) -> T

Generate a baseline value by calling the baseline closure.

Returns T by calling the baseline closure each time.

let inputs = InputPair::new(|| [0u8; 32], || rand::random());
let val = inputs.baseline();  // Calls || [0u8; 32]

pub fn sample(&self) -> T

Generate a sample value with anomaly tracking.

Calls the sample closure and tracks the hash for anomaly detection (only the first ANOMALY_DETECTION_WINDOW samples are tracked).

Note: This method includes tracking overhead. For timing-critical code, use generate_sample() during pre-generation and check anomalies after.

pub fn generate_sample(&self) -> T

Generate a sample value without anomaly tracking.

Use this for pre-generating inputs before measurement. After pre-generation, call track_value() on each value to enable anomaly detection.

This is used internally by TimingOracle::test() to avoid overhead during the measurement loop.

pub fn generate_baseline(&self) -> T

Generate a baseline value without any overhead.

Identical to baseline() but named for symmetry with generate_sample().

pub fn track_value(&self, value: &T)

Track a sample value for anomaly detection.

Call this on pre-generated sample values to enable anomaly detection without adding overhead during measurement.

pub fn check_anomaly(&self) -> Option<String>

Check if the sample generator appears to be producing constant values.

Returns a warning message if anomaly detected, None otherwise. Should be called after measurement completes.

Detected Anomalies

Condition	Severity	Message
All samples identical	Error	Likely captured pre-evaluated value
<50% unique samples	Warning	Low entropy, possible mistake
Normal entropy	OK	None

Example

// After running the test
if let Some(warning) = inputs.check_anomaly() {
    eprintln!("[tacet] {}", warning);
}

impl<T, F1, F2> InputPair<T, F1, F2>

where T: Clone, F1: FnMut() -> T, F2: FnMut() -> T,

pub fn new_untracked(baseline: F1, sample: F2) -> Self

Create without anomaly detection (for non-Hash types).

Use this when T doesn’t implement Hash (e.g., cryptographic scalars, field elements, big integers).

Example

// Scalar type that doesn't implement Hash
let inputs = InputPair::new_untracked(
    || Scalar::zero(),
    || Scalar::random(&mut rng)
);

pub fn baseline_untracked(&self) -> T

Generate a baseline value (untracked version).

pub fn sample_untracked(&self) -> T

Generate a sample value without tracking (for non-Hash types).

pub fn check_anomaly_untracked(&self) -> Option<String>

Check anomaly - always returns None for untracked InputPairs.

This method exists so code can call check_anomaly() uniformly without knowing whether tracking is enabled.