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, so Hashed does not implement OrderedTranslator and cannot back an ordered index or the ordered QMDB. It is safe for unordered indices and partitioned unordered indices.

An ordered index over Hashed does not compile:

use commonware_storage::{
    index::{Ordered, ordered::Index},
    translator::{Hashed, TwoCap},
};

fn ordered<I: Ordered>() {}
ordered::<Index<Hashed<TwoCap>, u64>>();

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) -> Self

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.