Struct Namespace

pub struct Namespace(/* private fields */);

Namespace of the data published to the celestia network.

The Namespace is a single byte defining the version followed by 28 bytes specifying concrete ID of the namespace.

Currently there are two versions of namespaces:

• version 0 - the one allowing for the custom namespace ids. It requires an id to start with 18 0x00 bytes followed by a user specified suffix (except reserved ones, see below).
• version 255 - for secondary reserved namespaces. It requires an id to start with 27 0xff bytes followed by a single byte indicating the id.

Some namespaces are reserved for the block creation purposes and cannot be used when submitting the blobs to celestia. Those fall into one of the two categories:

• primary reserved namespaces - those use version 0 and have id lower or equal to 0xff so they are always placed in blocks before user-submitted data.
• secondary reserved namespaces - those use version 0xff so they are always placed after user-submitted data.

Implementations

impl Namespace

pub const TRANSACTION: Namespace

Primary reserved Namespace for the compact Shares with cosmos SDK transactions.

pub const PAY_FOR_BLOB: Namespace

Primary reserved Namespace for the compact Shares with MsgPayForBlobs transactions.

pub const PRIMARY_RESERVED_PADDING: Namespace = Namespace::MAX_PRIMARY_RESERVED

Primary reserved Namespace for the Shares used for padding.

Shares with this namespace are inserted after other shares from primary reserved namespace so that user-defined namespaces are correctly aligned in ExtendedDataSquare

pub const MAX_PRIMARY_RESERVED: Namespace

Maximal primary reserved Namespace.

Used to indicate the end of the primary reserved group.

pub const MIN_SECONDARY_RESERVED: Namespace

Minimal secondary reserved Namespace.

Used to indicate the beginning of the secondary reserved group.

pub const TAIL_PADDING: Namespace

Secondary reserved Namespace used for padding after the blobs.

It is used to fill up the original data square after all user-submitted blobs before the parity data is generated for the ExtendedDataSquare.

pub const PARITY_SHARE: Namespace

The Namespace for parity shares.

It is the namespace with which all the parity shares from ExtendedDataSquare are inserted to the Nmt when computing merkle roots.

pub fn from_raw(bytes: &[u8]) -> Result<Self>

Create a new Namespace from the raw bytes.

Errors

This function will return an error if the slice length is different than NS_SIZE or if the namespace is invalid. If you are constructing the version 0 namespace, check new_v0 for more details.

Example

use celestia_types::nmt::{Namespace, NS_SIZE};
let raw = [0; NS_SIZE];
let namespace = Namespace::from_raw(&raw).unwrap();

pub fn new(version: u8, id: &[u8]) -> Result<Self>

Create a new Namespace from the version and id.

Errors

This function will return an error if provided namespace version isn’t supported or if the namespace is invalid. If you are constructing the version 0 namespace, check new_v0 for more details.

Example

use celestia_types::nmt::Namespace;
let namespace = Namespace::new(0, b"custom-ns").unwrap();

pub fn new_v0(id: &[u8]) -> Result<Self>

Create a new Namespace version 0 with given id.

The id must be either:

• a 28 byte slice specifying full id
• a 10 or less byte slice specifying user-defined suffix

Namespaces in version 0 must have id’s prefixed with 18 0x00 bytes.

Errors

This function will return an error if the provided id has incorrect length or if the id has 28 bytes and have doesn’t have mandatory 18x0x00 bytes prefix

Example

use celestia_types::nmt::Namespace;

// construct using 28 byte slice
let id = [0u8; 28];
let namespace = Namespace::new_v0(&id).unwrap();

// construct using <=10 byte suffix
let namespace = Namespace::new_v0(b"any-suffix").unwrap();

// invalid
let mut id = [0u8; 28];
id[4] = 1;
let namespace = Namespace::new_v0(&id).unwrap_err();

pub const fn const_v0(id: [u8; 10]) -> Self

Create a new Namespace version 0 with a given id.

Example

use celestia_types::nmt::Namespace;

const NAMESPACE: Namespace = Namespace::const_v0([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);

pub const fn const_v255(id: u8) -> Self

Create a new Namespace version 255 with a given id.

Example

use celestia_types::nmt::Namespace;

const NAMESPACE: Namespace = Namespace::const_v255(0xff);

assert_eq!(NAMESPACE, Namespace::PARITY_SHARE);

pub fn new_v255(id: &[u8]) -> Result<Self>

Create a new Namespace version 255 with a given id.

Namespaces with version 255 must have ids prefixed with 27 0xff bytes followed by a single byte with an actual id.

Errors

This function will return an error, if the provided id has incorrect length or if the id prefix is incorrect.

Example

use celestia_types::nmt::Namespace;

// construct using 28 byte slice
let id = [255u8; 28];
let namespace = Namespace::new_v255(&id).unwrap();

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

Converts the Namespace to a byte slice.

pub fn version(&self) -> u8

Returns the first byte indicating the version of the Namespace.

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

Returns the trailing 28 bytes indicating the id of the Namespace.

pub fn id_v0(&self) -> Option<&[u8]>

Returns the 10 bytes user-defined suffix of the Namespace if it’s a version 0.

pub fn is_reserved(&self) -> bool

Returns true if the namespace is reserved for special purposes.

Example

use celestia_types::nmt::Namespace;

let ns = Namespace::new_v0(b"lumina").unwrap();
assert!(!ns.is_reserved());

assert!(Namespace::PAY_FOR_BLOB.is_reserved());
assert!(Namespace::PARITY_SHARE.is_reserved());

Methods from Deref<Target = NamespaceId<NS_SIZE>>

pub const MAX_ID: NamespaceId<NS_ID_SIZE>

pub const MAX_RESERVED_ID_ON_CELESTIA: NamespaceId<NS_ID_SIZE>

pub fn is_reserved_on_celestia(&self) -> bool

Indicates whether the namespace is reserved for system data on Celestia.

Trait Implementations

impl Clone for Namespace

fn clone(&self) -> Namespace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Namespace

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

Formats the value using the given formatter.

impl Deref for Namespace

type Target = NamespaceId<NS_SIZE>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for Namespace

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Namespace> for NamespaceId<NS_SIZE>

fn from(value: Namespace) -> Self

Converts to this type from the input type.

impl From<NamespaceId<NS_SIZE>> for Namespace

fn from(value: NamespaceId<NS_SIZE>) -> Self

Converts to this type from the input type.

impl Hash for Namespace

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Namespace

fn cmp(&self, other: &Namespace) -> 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,

Restrict a value to a certain interval.

impl PartialEq for Namespace

fn eq(&self, other: &Namespace) -> 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 Namespace

fn partial_cmp(&self, other: &Namespace) -> 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 Namespace

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 Namespace

impl Eq for Namespace

impl StructuralPartialEq for Namespace