Struct Blob

pub struct Blob {
    pub namespace: Namespace,
    pub data: Vec<u8>,
    pub share_version: u8,
    pub commitment: Commitment,
    pub index: Option<u64>,
    pub signer: Option<AccAddress>,
}

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.

index: Option<u64>

Index of the blob’s first share in the EDS. Only set for blobs retrieved from chain.

signer: Option<AccAddress>

A signer of the blob, i.e. address of the account which submitted the blob.

Must be present in share_version 1 and absent otherwise.

Implementations

impl Blob

pub fn new( namespace: Namespace, data: Vec<u8>, app_version: AppVersion, ) -> 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::{AppVersion, 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(), AppVersion::V2)
    .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=",
      "index": -1,
      "signer": null
    }"#},
);

pub fn new_with_signer( namespace: Namespace, data: Vec<u8>, signer: AccAddress, app_version: AppVersion, ) -> Result<Blob>

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

Errors

This function propagates any error from the Commitment creation. Also AppVersion must be at least AppVersion::V3.

pub fn from_raw(raw: RawBlob, app_version: AppVersion) -> Result<Blob>

Creates a Blob from RawBlob and an AppVersion.

pub fn validate(&self, app_version: AppVersion) -> 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(), AppVersion::V2).unwrap();

assert!(blob.validate(AppVersion::V2).is_ok());

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

assert!(blob.validate(AppVersion::V2).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(), AppVersion::V2).unwrap();
let shares = blob.to_shares().unwrap();

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

pub fn reconstruct<'a, I>(shares: I, app_version: AppVersion) -> Result<Self>

where I: IntoIterator<Item = &'a Share>,

Reconstructs a blob from shares.

Errors

This function will return an error if:

• there is not enough shares to reconstruct the blob
• blob doesn’t start with the first share
• shares are from any reserved namespace
• shares for the blob have different namespaces / share version

Example

use celestia_types::{AppVersion, Blob};

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

let reconstructed = Blob::reconstruct(&shares, AppVersion::V2).unwrap();

assert_eq!(blob, reconstructed);

pub fn reconstruct_all<'a, I>( shares: I, app_version: AppVersion, ) -> Result<Vec<Self>>

where I: IntoIterator<Item = &'a Share>,

Reconstructs all the blobs from shares.

This function will seek shares that indicate start of the next blob (with Share::sequence_length) and pass them to Blob::reconstruct. It will automatically ignore all shares that are within reserved namespaces e.g. it is completely fine to pass whole ExtendedDataSquare to this function and get all blobs in the block.

Errors

This function propagates any errors from Blob::reconstruct.

Example

use celestia_types::{AppVersion, Blob};

let blobs = vec![
    Blob::new(namespace1, b"foo".to_vec(), AppVersion::V2).unwrap(),
    Blob::new(namespace2, b"bar".to_vec(), AppVersion::V2).unwrap(),
];
let shares: Vec<_> = blobs.iter().flat_map(|blob| blob.to_shares().unwrap()).collect();

let reconstructed = Blob::reconstruct_all(&shares, AppVersion::V2).unwrap();

assert_eq!(blobs, reconstructed);

pub fn shares_len(&self) -> usize

Get the amount of shares needed to encode this blob.

Example

use celestia_types::{AppVersion, Blob};

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

let blob_shares = blob.to_shares().unwrap();

assert_eq!(shares_len, blob_shares.len());

Trait Implementations

impl Clone for Blob

fn clone(&self) -> Blob

Returns a duplicate of the value.

const 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 RawBlob

fn from(value: Blob) -> RawBlob

Converts to this type from the input type.

impl PartialEq for Blob

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

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

const 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 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 Eq for Blob

impl StructuralPartialEq for Blob