Struct handshakes::types::covenant::Covenant

pub struct Covenant {
    pub covenant_type: CovenantType,
    pub covenant_data: CovenantData,
}

A Covenant is a part of a Handshake UTXO that restricts how the UTXO may be spent over the period of multiple spends. It is able to maintain data over time.

Fields

covenant_type: CovenantType

The CovenantType restricts spending to other CovenantTypes that have a defined spending path. State machines can be constructed this way that enable the auction system.

covenant_data: CovenantData

The CovenantData represents Covenant specific data that is attached to the UTXO. This data must be updated correctly as the UTXO is spent from one CovenantType to the next CovenantType.

Implementations

impl Covenant

pub fn null() -> Self

Returns the null Covenant.

Trait Implementations

impl ByteFormat for Covenant

type Error = SerError

An associated error type

fn serialized_length(&self) -> usize

Returns the byte-length of the serialized data structure.

fn read_from<R>(reader: &mut R) -> SerResult<Self> where
    R: Read,
    Self: Sized, 

Deserializes an instance of Self from a std::io::Read. The limit argument is used only when deserializing collections, and specifies a maximum number of instances of the underlying type to read.

fn write_to<W>(&self, writer: &mut W) -> SerResult<usize> where
    W: Write, 

Serializes self to a std::io::Write. Following Write trait conventions, its Ok type must be a usize denoting the number of bytes written.

fn read_seq_from<R>(
    reader: &mut R,
    mode: ReadSeqMode
) -> Result<Vec<Self, Global>, Self::Error> where
    R: Read, 

Read a sequence of exactly limit objects from the reader.

fn write_seq_to<'a, W, E, Iter, Item>(
    writer: &mut W,
    iter: Iter
) -> Result<usize, Self::Error> where
    W: Write,
    E: Into<Self::Error> + From<SerError> + From<Error> + Error,
    Item: 'a + ByteFormat<Error = E>,
    Iter: IntoIterator<Item = &'a Item>, 

Write a sequence of ByteFormat objects to a writer. The iter argument may be any object that implements IntoIterator<Item = &Item>. This means we can seamlessly use vectors, slices, etc.

fn deserialize_hex(s: &str) -> Result<Self, Self::Error>

Decodes a hex string to a Vec<u8>, deserializes an instance of Self from that vector.

fn deserialize_base64(s: &str) -> Result<Self, Self::Error>

Serialize self to a base64 string, using standard RFC4648 non-url safe characters

fn serialize_hex(&self) -> String

Serializes self to a vector, returns the hex-encoded vector

fn serialize_base64(&self) -> String

Serialize self to a base64 string, using standard RFC4648 non-url safe characters

impl Clone for Covenant

fn clone(&self) -> Covenant

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Covenant

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Covenant

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<Covenant> for Covenant

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

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

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

This method tests for !=.

impl Serialize for Covenant

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 Covenant

impl StructuralEq for Covenant

impl StructuralPartialEq for Covenant