Struct Hasher 

pub struct Hasher<const BODY_SIZE: usize = DEFAULT_BODY_SIZE> { /* private fields */ }

BMT hasher with configurable body size.

Implementations

impl<const BODY_SIZE: usize> Hasher<BODY_SIZE>

pub const fn new() -> Self

Create a new BMT hasher.

pub const fn set_span(&mut self, span: u64)

Set the span of data to be hashed

pub const fn span(&self) -> u64

Get the current span

pub fn prefix_with(&mut self, prefix: &[u8])

Add a prefix to the hash calculation.

The prefix is applied to every Keccak256 invocation in the tree (leaf sections, internal nodes and the final span wrap), matching bee’s swarm.NewPrefixHasher semantics where Reset() re-writes the prefix as the first bytes before each node hash. This makes the resulting root byte-identical to bee’s transformedAddress.

pub fn with_prefix(prefix: &[u8]) -> Self

Create a new BMT hasher pre-configured with an anchor prefix.

Equivalent to Hasher::new followed by Hasher::prefix_with. The prefix is mixed into every node hash (see Hasher::prefix_with), so the produced root matches bee’s anchor-keyed transformedAddress.

pub fn prefix(&self) -> &[u8]

Get the current prefix

pub const fn position(&self) -> usize

Get the current cursor position

pub const fn len(&self) -> usize

Get the amount of data currently in the buffer

pub const fn is_empty(&self) -> bool

Check if the buffer is empty

pub fn update(&mut self, data: &[u8])

Update the hasher with more data (non-destructive)

pub fn hash(&self, out: &mut [u8])

Compute the BMT hash and write to output buffer.

pub fn sum(&self) -> B256

Compute the BMT hash and return the result (non-destructive)

pub fn data(&self) -> Bytes

Get the current data as Bytes (immutable reference)

pub fn get_level_segments(&self, data: &[u8]) -> Vec<B256>

Get segments for the current level of data

Trait Implementations

impl<const BODY_SIZE: usize> Clone for Hasher<BODY_SIZE>

fn clone(&self) -> Hasher<BODY_SIZE>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const BODY_SIZE: usize> Debug for Hasher<BODY_SIZE>

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

Formats the value using the given formatter.

impl<const BODY_SIZE: usize> Default for Hasher<BODY_SIZE>

fn default() -> Self

Returns the “default value” for a type.

impl<const BODY_SIZE: usize> FixedOutput for Hasher<BODY_SIZE>

fn finalize_into(self, out: &mut Array<u8, Self::OutputSize>)

Consume value and write result into provided array.

fn finalize_fixed(self) -> Array<u8, Self::OutputSize>

Retrieve result and consume the hasher instance.

impl<const BODY_SIZE: usize> FixedOutputReset for Hasher<BODY_SIZE>

fn finalize_into_reset(&mut self, out: &mut Array<u8, Self::OutputSize>)

Write result into provided array and reset the hasher state.

fn finalize_fixed_reset(&mut self) -> Array<u8, Self::OutputSize>

Retrieve result and reset the hasher state.

impl<const BODY_SIZE: usize> HashMarker for Hasher<BODY_SIZE>

impl<const BODY_SIZE: usize> OutputSizeUser for Hasher<BODY_SIZE>

type OutputSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>

Size of the output in bytes.

fn output_size() -> usize

Return output size in bytes.

impl Prover for Hasher

fn generate_proof(&self, data: &[u8], segment_index: usize) -> Result<Proof>

Generate a proof for a specific segment

fn verify_proof(proof: &Proof, root_hash: &[u8]) -> Result<bool>

Verify a proof against a root hash

impl<const BODY_SIZE: usize> Reset for Hasher<BODY_SIZE>

fn reset(&mut self)

Reset state to its initial value.

impl<const BODY_SIZE: usize> Update for Hasher<BODY_SIZE>

fn update(&mut self, data: &[u8])

Update state using the provided data.

fn chain(self, data: impl AsRef<[u8]>) -> Self

where Self: Sized,

Digest input data in a chained manner.

impl<const BODY_SIZE: usize> Write for Hasher<BODY_SIZE>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.