Struct celestia_types::blob::Commitment

pub struct Commitment(pub Hash);

A merkle hash used to identify the Blobs data.

In Celestia network, the transaction which pays for the blob’s inclusion is separated from the data itself. The reason for that is to allow verifying the blockchain’s state without the need to pull the actual data which got stored. To achieve that, the MsgPayForBlobs transaction only includes the Commitments of the blobs it is paying for, not the data itself.

The algorithm of computing the Commitment of the Blob’s Shares is designed in a way to allow easy and cheap proving of the Shares inclusion in the block. It is computed as a merkle hash of all the Nmt subtree roots created from the blob shares included in the ExtendedDataSquare rows. Assuming the s1 and s2 are the only shares of some blob posted to the celestia, they’ll result in a single subtree root as shown below:

NMT:           row root
               /     \
             o   subtree root
            / \      / \
          _________________
EDS row: | s | s | s1 | s2 |

Using subtree roots as a base for Commitment computation allows for much smaller inclusion proofs than when the Shares would be used directly, but it imposes some constraints on how the Blobs can be placed in the ExtendedDataSquare. You can read more about that in the share commitment rules.

Tuple Fields

0: Hash

Implementations

impl Commitment

pub fn from_blob( namespace: Namespace, share_version: u8, blob_data: &[u8], ) -> Result<Commitment>

Generate the share commitment from the given blob data.

pub fn from_shares(namespace: Namespace, shares: &[Share]) -> Result<Commitment>

Generate the commitment from the given shares.

Trait Implementations

impl Clone for Commitment

fn clone(&self) -> Commitment

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Commitment

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Commitment

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Ord for Commitment

fn cmp(&self, other: &Commitment) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Commitment

fn eq(&self, other: &Commitment) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Commitment

fn partial_cmp(&self, other: &Commitment) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Commitment

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Commitment

impl Eq for Commitment

impl StructuralPartialEq for Commitment