Enum NoteExecutionHint

pub enum NoteExecutionHint {
    None,
    Always,
    AfterBlock {
        block_num: AfterBlockNumber,
    },
    OnBlockSlot {
        round_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.

Felt layout

NoteExecutionHint can be encoded into a Felt with the following layout:

[26 zero bits | payload (32 bits) | tag (6 bits)]

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

Variants

None

Unspecified note execution hint. Implies it is not known 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 number.

The block number cannot be u32::MAX which is enforced through the AfterBlockNumber type.

Fields

block_num: AfterBlockNumber

OnBlockSlot

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

The slot is defined as follows:

• First we define the length of the round in powers of 2. For example, round_len = 10 is a round of 1024 blocks.
• Then we define the length of a slot within the round 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 round - i.e., 0 is the first slot, 1 is the second slot etc.

For example: { round_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 round. These would be blocks 128..255, 1152..1279, 2176..2303 etc.

Fields

round_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: BlockNumber) -> Result<Self, NoteError>

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

Errors

Returns an error if block_num is equal to u32::MAX.

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

Creates a NoteExecutionHint::OnBlockSlot for the given parameters. See the variants documentation for details on the parameters.

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

pub fn can_be_consumed(&self, block_num: BlockNumber) -> 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)

Encodes the NoteExecutionHint into a 6-bit tag and a 32-bit payload.

Guarantees

Since the tag has at most 6 bits, the returned byte is guaranteed to have its two most significant bits set to 0.

The payload is guaranteed to contain at least one 0 bit to make encoding it into NoteMetadata safely possible.

Trait Implementations

impl Clone for NoteExecutionHint

fn clone(&self) -> NoteExecutionHint

Returns a duplicate 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

Converts a NoteExecutionHint into a Felt with the layout documented on the type.

fn from(value: NoteExecutionHint) -> Self

Converts to this type from the input type.

impl From<NoteExecutionHint> for u64

Converts a NoteExecutionHint into a u64 with the layout documented on the type.

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

Tries to convert a u64 into a NoteExecutionHint with the expected layout documented on the type.

Note: The upper 26 bits are not enforced to be zero.

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