Struct celestia_types::blob::Blob

pub struct Blob {
    pub namespace: Namespace,
    pub data: Vec<u8>,
    pub share_version: u8,
    pub commitment: Commitment,
}

Arbitrary data that can be stored in the network within certain Namespace.

Fields

namespace: Namespace

A Namespace the Blob belongs to.

data: Vec<u8>

Data stored within the Blob.

share_version: u8

Version indicating the format in which Shares should be created from this Blob.

commitment: Commitment

A Commitment computed from the Blobs data.

Implementations

impl Blob

pub fn new(namespace: Namespace, data: Vec<u8>) -> Result<Blob>

Create a new blob with the given data within the Namespace.

Errors

This function propagates any error from the Commitment creation.

Example

use celestia_types::{Blob, nmt::Namespace};

let my_namespace = Namespace::new_v0(&[1, 2, 3, 4, 5]).expect("Invalid namespace");
let blob = Blob::new(my_namespace, b"some data to store on blockchain".to_vec())
    .expect("Failed to create a blob");

assert_eq!(
    &serde_json::to_string_pretty(&blob).unwrap(),
    indoc::indoc! {r#"{
      "namespace": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIDBAU=",
      "data": "c29tZSBkYXRhIHRvIHN0b3JlIG9uIGJsb2NrY2hhaW4=",
      "share_version": 0,
      "commitment": "m0A4feU6Fqd5Zy9td3M7lntG8A3PKqe6YdugmAsWz28="
    }"#},
);

pub fn validate(&self) -> Result<()>

Validate Blobs data with the Commitment it has.

Errors

If validation fails, this function will return an error with a reason of failure.

Example

use celestia_types::Blob;

let mut blob = Blob::new(namespace, b"foo".to_vec()).unwrap();

assert!(blob.validate().is_ok());

let other_blob = Blob::new(namespace, b"bar".to_vec()).unwrap();
blob.commitment = other_blob.commitment;

assert!(blob.validate().is_err());

pub fn to_shares(&self) -> Result<Vec<Share>>

Encode the blob into a sequence of shares.

Check the Share documentation for more information about the share format.

Errors

This function will return an error if InfoByte creation fails or the data length overflows u32.

Example

use celestia_types::Blob;

let blob = Blob::new(namespace, b"foo".to_vec()).unwrap();
let shares = blob.to_shares().unwrap();

assert_eq!(shares.len(), 1);

Trait Implementations

impl Clone for Blob

fn clone(&self) -> Blob

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Blob

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Blob

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Blob> for Blob

fn from(value: Blob) -> RawBlob

Converts to this type from the input type.

impl PartialEq for Blob

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Protobuf<Blob> for Blob

fn encode<B>(&self, buf: &mut B) -> Result<(), Error>

where B: BufMut,

Encode into a buffer in Protobuf format.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), Error>

where B: BufMut,

Encode with a length-delimiter to a buffer in Protobuf format.

fn decode<B>(buf: B) -> Result<Self, Error>

where B: Buf,

Constructor that attempts to decode an instance from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, Error>

where B: Buf,

Constructor that attempts to decode a length-delimited instance from the buffer.

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn encode_vec(&self) -> Result<Vec<u8>, Infallible>

Encodes into a Protobuf-encoded Vec<u8>.

fn decode_vec(v: &[u8]) -> Result<Self, Error>

Constructor that attempts to decode a Protobuf-encoded instance from a Vec<u8> (or equivalent).

fn encode_length_delimited_vec(&self) -> Result<Vec<u8>, Infallible>

Encode with a length-delimiter to a Vec<u8> Protobuf-encoded message.

fn decode_length_delimited_vec(v: &[u8]) -> Result<Self, Error>

Constructor that attempts to decode a Protobuf-encoded instance with a length-delimiter from a Vec<u8> or equivalent.

impl Serialize for Blob

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Blob> for Blob

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: RawBlob) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for Blob

impl StructuralPartialEq for Blob