Trait strict_encoding::StrictEncode

pub trait StrictEncode {
    pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>;

    pub fn strict_serialize(&self) -> Result<Vec<u8>, Error> { ... }
}

Binary encoding according to the strict rules that usually apply to consensus-critical data structures. May be used for network communications; in some circumstances may be used for commitment procedures; however it must be kept in mind that sometime commitment may follow "fold" scheme (Merklization or nested commitments) and in such cases this trait can't be applied. It is generally recommended for consensus-related commitments to utilize [CommitVerify], [TryCommitVerify] and [EmbedCommitVerify] traits
from [paradigms::commit_verify] module.

Required methods

pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

Encode with the given [std::io::Writer] instance; must return result with either amount of bytes encoded – or implementation-specific error type.

Loading content...

Provided methods

pub fn strict_serialize(&self) -> Result<Vec<u8>, Error>

Serializes data as a byte array using [strict_encode()] function

Loading content...

Implementations on Foreign Types

impl StrictEncode for Script

pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

impl StrictEncode for SecretKey

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for PublicKey

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for Signature

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for PublicKey

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for Network

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for ChildNumber

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for DerivationPath

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for ChainCode

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for Fingerprint

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for ExtendedPubKey

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for ExtendedPrivKey

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for &[u8]

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for [u8; 32]

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for Box<[u8]>

pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

impl StrictEncode for &str

pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

impl StrictEncode for String

pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

impl<T> StrictEncode for Option<T> where
    T: StrictEncode, 

In terms of strict encoding, Option (optional values) are
represented by a significator byte, which MUST be either 0 (for no value present) or 1, followed by the value strict encoding.

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl<T> StrictEncode for Vec<T> where
    T: StrictEncode, 

In terms of strict encoding, Vec is stored in form of usize-encoded length (see StrictEncode implementation for usize type for encoding platform-independent constant-length encoding rules) followed by a consequently-encoded vec items, according to their type.

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl<T> StrictEncode for HashSet<T> where
    T: StrictEncode + Eq + Ord + Hash + Debug, 

Strict encoding for a unique value collection represented by a rust HashSet type is performed in the same way as Vec encoding. NB: Array members must are ordered with the sort operation, so type T must implement Ord trait in such a way that it produces deterministically-sorted result

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl<T> StrictEncode for BTreeSet<T> where
    T: StrictEncode + Eq + Ord + Debug, 

Strict encoding for a unique value collection represented by a rust BTreeSet type is performed in the same way as Vec encoding. NB: Array members must are ordered with the sort operation, so type T must implement Ord trait in such a way that it produces deterministically-sorted result

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl<T> StrictEncode for HashMap<usize, T> where
    T: StrictEncode + Clone, 

LNP/BP library uses HashMap<usize, T: StrictEncode>s to encode ordered lists, where the position of the list item must be fixed, since the item is referenced from elsewhere by its index. Thus, the library does not supports and recommends not to support strict encoding of any other HashMap variants.

Strict encoding of the HashMap<usize, T> type is performed by converting into a fixed-order Vec<T> and serializing it according to the Vec strict encoding rules. This operation is internally performed via conversion into BTreeMap<usize, T: StrictEncode>.

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl<K, V> StrictEncode for BTreeMap<K, V> where
    K: StrictEncode + Ord + Clone,
    V: StrictEncode + Clone, 

LNP/BP library uses BTreeMap<usize, T: StrictEncode>s to encode ordered lists, where the position of the list item must be fixed, since the item is referenced from elsewhere by its index. Thus, the library does not supports and recommends not to support strict encoding of any other BTreeMap variants.

Strict encoding of the BTreeMap<usize, T> type is performed by converting into a fixed-order Vec<T> and serializing it according to the Vec strict encoding rules.

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl<K, V> StrictEncode for (K, V) where
    K: StrictEncode + Clone,
    V: StrictEncode + Clone, 

Two-component tuples are encoded as they were fields in the parent data structure

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for bool

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for usize

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for f32

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for f64

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for Duration

pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

impl StrictEncode for NaiveDateTime

pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

impl<T> StrictEncode for Holder<T, Wrapped> where
    T: Wrapper,
    T::Inner: StrictEncode, 

pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

impl<T> StrictEncode for Holder<T, HashFixedBytes> where
    T: Hash, 

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl<T> StrictEncode for Holder<T, BitcoinConsensus> where
    T: Encodable, 

pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

impl<T> StrictEncode for Holder<T, UsingUniformAddr> where
    T: Uniform, 

pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

Loading content...

Implementors

impl StrictEncode for RawAddr

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl StrictEncode for RawUniformAddr

pub fn strict_encode<E: Write>(&self, mut e: E) -> Result<usize, Error>

impl<T> StrictEncode for T where
    T: Strategy + Clone,
    Holder<T, <T as Strategy>::Strategy>: StrictEncode, 

pub fn strict_encode<E: Write>(&self, e: E) -> Result<usize, Error>

Loading content...