Enum NoteExecutionHint

pub enum NoteExecutionHint {
    None,
    Always,
    AfterBlock {
        block_num: u32,
    },
    OnBlockSlot {
        epoch_len: u8,
        slot_len: u8,
        slot_offset: u8,
    },
}

Specifies the conditions under which a note is ready to be consumed. These conditions are meant to be encoded in the note script as well.

This struct can be represented as the combination of a tag, and a payload. The tag specifies the variant of the hint, and the payload encodes the hint data.

Variants

None

Unspecified note execution hint. Implies it is not knorn under which conditions the note is consumable.

Always

The note’s script can be executed at any time.

AfterBlock

The note’s script can be executed after the specified block height.

Fields

block_num: u32

OnBlockSlot

The note’s script can be executed in the specified slot within the specified epoch.

The slot is defined as follows:

• First we define the length of the epoch in powers of 2. For example, epoch_len = 10 is an epoch of 1024 blocks.
• Then we define the length of a slot within the epoch also using powers of 2. For example, slot_len = 7 is a slot of 128 blocks.
• Lastly, the offset specifies the index of the slot within the epoch - i.e., 0 is the first slot, 1 is the second slot etc.

For example: { epoch_len: 10, slot_len: 7, slot_offset: 1 } means that the note can be executed in any second 128 block slot of a 1024 block epoch. These would be blocks 128..255, 1152..1279, 2176..2303 etc.

Fields

epoch_len: u8

slot_len: u8

slot_offset: u8

Implementations

impl NoteExecutionHint

pub fn none() -> Self

Creates a NoteExecutionHint::None variant

pub fn always() -> Self

Creates a NoteExecutionHint::Always variant

pub fn after_block(block_num: u32) -> Self

Creates a NoteExecutionHint::AfterBlock variant based on the given block_num

pub fn on_block_slot(epoch_len: u8, slot_len: u8, slot_offset: u8) -> Self

Creates a NoteExecutionHint::OnBlockSlot for the given parameters

pub fn from_parts(tag: u8, payload: u32) -> Result<NoteExecutionHint, NoteError>

pub fn can_be_consumed(&self, block_num: u32) -> Option<bool>

Returns whether the note execution conditions validate for the given block_num

Returns

• None if we don’t know whether the note can be consumed.
• Some(true) if the note is consumable for the given block_num
• Some(false) if the note is not consumable for the given block_num

pub fn into_parts(&self) -> (u8, u32)

Trait Implementations

impl Clone for NoteExecutionHint

fn clone(&self) -> NoteExecutionHint

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NoteExecutionHint

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

Formats the value using the given formatter.

impl From<NoteExecutionHint> for Felt

As a Felt, the ExecutionHint is encoded as:

• 6 least significant bits: Hint identifier (tag).
• Bits 6 to 38: Hint payload.

This way, hints such as NoteExecutionHint::Always, are represented by Felt::new(1)

fn from(value: NoteExecutionHint) -> Self

Converts to this type from the input type.

impl From<NoteExecutionHint> for u64

fn from(value: NoteExecutionHint) -> Self

Converts to this type from the input type.

impl PartialEq for NoteExecutionHint

fn eq(&self, other: &NoteExecutionHint) -> 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 TryFrom<u64> for NoteExecutionHint

As a u64, the ExecutionHint is encoded as:

• 6 least significant bits: Hint identifier (tag).
• Bits 6 to 38: Hint payload.

This way, hints such as NoteExecutionHint::Always, are represented by 1u64

type Error = NoteError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for NoteExecutionHint

impl Eq for NoteExecutionHint

impl StructuralPartialEq for NoteExecutionHint