Struct Hashed 

pub struct Hashed<T: Translator> { /* private fields */ }

Collision-resistant wrapper for any Translator.

Hashes the full key with a per-instance secret seed before delegating to the inner translator. This makes translated-key collisions unpredictable to an adversary who does not know the seed, similar to how std::collections::HashMap uses std::collections::hash_map::RandomState to prevent HashDoS attacks. It can also be used to ensure uniform distribution of skewed keyspaces when used by non-hashing structures such as crate::index.

No Ordering

Hashing destroys lexicographic key ordering. Do not use Hashed with ordered indices when callers rely on translated-key adjacency matching original-key adjacency (e.g., exclusion proofs in the ordered QMDB). Hashed is safe for unordered indices and partitioned unordered indices.

no_std Support

Hashed::new and Default are available only with this crate’s std feature. They use ahash::RandomState::new, which requires OS-provided randomness (the runtime-rng feature of ahash, enabled by std here). In no_std environments, use Hashed::from_seed with an externally-sourced random seed instead.

No Stability Guarantees

ahash::RandomState is used as the underlying hasher. While ahash is robust, its exact algorithm might change across versions. As a result, transformed outputs are not stable across Rust versions or platforms. Treat this translator as an in-memory collision-hardening mechanism, not as a stable/persisted encoding.

Examples

use commonware_storage::translator::{Hashed, TwoCap, Translator};

// Random seed (production use, requires `std`):
let t = Hashed::new(TwoCap);
let _k = t.transform(b"hello");

// Deterministic seed (testing within the same toolchain/runtime):
let t = Hashed::from_seed(42, TwoCap);
assert_eq!(t.transform(b"hello"), t.transform(b"hello"));

Implementations

impl<T: Translator> Hashed<T>

pub fn new(inner: T) -> Self

Create a new Hashed translator with a random seed.

pub const fn from_seed(seed: u64, inner: T) -> Self

Create a new Hashed translator with a specific seed.

Trait Implementations

impl<T: Translator> BuildHasher for Hashed<T>

type Hasher = <T as BuildHasher>::Hasher

Type of the hasher that will be created.

fn build_hasher(&self) -> Self::Hasher

Creates a new hasher.

fn hash_one<T>(&self, x: T) -> u64

where T: Hash, Self: Sized, Self::Hasher: Hasher,

Calculates the hash of a single value.

impl<T: Clone + Translator> Clone for Hashed<T>

fn clone(&self) -> Hashed<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Translator + Default> Default for Hashed<T>

Available on crate feature std only.

fn default() -> Self

Returns the “default value” for a type.

impl<T: Translator> Translator for Hashed<T>

type Key = <T as Translator>::Key

The type of the internal representation of keys.

fn transform(&self, key: &[u8]) -> T::Key

Transform a key into its new representation.