Enum cairo_lang_casm::hints::Hint

pub enum Hint {
    AllocSegment {
        dst: CellRef,
    },
    TestLessThan {
        lhs: ResOperand,
        rhs: ResOperand,
        dst: CellRef,
    },
    TestLessThanOrEqual {
        lhs: ResOperand,
        rhs: ResOperand,
        dst: CellRef,
    },
    DivMod {
        lhs: ResOperand,
        rhs: ResOperand,
        quotient: CellRef,
        remainder: CellRef,
    },
    Uint256DivMod {
        dividend_low: ResOperand,
        dividend_high: ResOperand,
        divisor_low: ResOperand,
        divisor_high: ResOperand,
        quotient0: CellRef,
        quotient1: CellRef,
        divisor0: CellRef,
        divisor1: CellRef,
        extra0: CellRef,
        extra1: CellRef,
        remainder_low: CellRef,
        remainder_high: CellRef,
    },
    SquareRoot {
        value: ResOperand,
        dst: CellRef,
    },
    LinearSplit {
        value: ResOperand,
        scalar: ResOperand,
        max_x: ResOperand,
        x: CellRef,
        y: CellRef,
    },
    AllocFelt252Dict {
        segment_arena_ptr: ResOperand,
    },
    Felt252DictRead {
        dict_ptr: ResOperand,
        key: ResOperand,
        value_dst: CellRef,
    },
    Felt252DictWrite {
        dict_ptr: ResOperand,
        key: ResOperand,
        value: ResOperand,
    },
    GetSegmentArenaIndex {
        dict_end_ptr: ResOperand,
        dict_index: CellRef,
    },
    InitSquashData {
        dict_accesses: ResOperand,
        ptr_diff: ResOperand,
        n_accesses: ResOperand,
        big_keys: CellRef,
        first_key: CellRef,
    },
    GetCurrentAccessIndex {
        range_check_ptr: ResOperand,
    },
    ShouldSkipSquashLoop {
        should_skip_loop: CellRef,
    },
    GetCurrentAccessDelta {
        index_delta_minus1: CellRef,
    },
    ShouldContinueSquashLoop {
        should_continue: CellRef,
    },
    AssertCurrentAccessIndicesIsEmpty,
    AssertAllAccessesUsed {
        n_used_accesses: CellRef,
    },
    AssertAllKeysUsed,
    GetNextDictKey {
        next_key: CellRef,
    },
    AssertLtAssertValidInput {
        a: ResOperand,
        b: ResOperand,
    },
    AssertLeFindSmallArcs {
        range_check_ptr: ResOperand,
        a: ResOperand,
        b: ResOperand,
    },
    AssertLeIsFirstArcExcluded {
        skip_exclude_a_flag: CellRef,
    },
    AssertLeIsSecondArcExcluded {
        skip_exclude_b_minus_a: CellRef,
    },
    AssertLeAssertThirdArcExcluded,
    RandomEcPoint {
        x: CellRef,
        y: CellRef,
    },
    FieldSqrt {
        val: ResOperand,
        sqrt: CellRef,
    },
    SystemCall {
        system: ResOperand,
    },
    DebugPrint {
        start: ResOperand,
        end: ResOperand,
    },
    AllocConstantSize {
        size: ResOperand,
        dst: CellRef,
    },
    SetBlockNumber {
        value: ResOperand,
    },
    SetBlockTimestamp {
        value: ResOperand,
    },
    SetCallerAddress {
        value: ResOperand,
    },
    SetContractAddress {
        value: ResOperand,
    },
    SetSequencerAddress {
        value: ResOperand,
    },
}

Variants

AllocSegment

Fields

dst: CellRef

TestLessThan

Fields

lhs: ResOperand

rhs: ResOperand

dst: CellRef

TestLessThanOrEqual

Fields

lhs: ResOperand

rhs: ResOperand

dst: CellRef

DivMod

Fields

lhs: ResOperand

rhs: ResOperand

quotient: CellRef

remainder: CellRef

Uint256DivMod

Fields

dividend_low: ResOperand

dividend_high: ResOperand

divisor_low: ResOperand

divisor_high: ResOperand

quotient0: CellRef

quotient1: CellRef

divisor0: CellRef

divisor1: CellRef

extra0: CellRef

extra1: CellRef

remainder_low: CellRef

remainder_high: CellRef

Divides dividend_low<<128+dividend_high by divisor_low<<128+divisor_high. Splits the remainder to 128bit words: remainder_low and remainder_high. Splits the quotient and the divisor to 128bit words. The lower 128 bits of the quotient are written to quotient0 and quotient1. The lower 128 bits of the divisor are written to divisor0 and divisor1. If the divisor is greater than 2^128, the upper 128 bits of the divisor are written to extra0 and extra1. In this case, quotient must be lower than 2^128. Otherwise, the upper 128 bits of the quotient are written to extra0 and extra1.

SquareRoot

Fields

value: ResOperand

dst: CellRef

LinearSplit

Fields

value: ResOperand

scalar: ResOperand

max_x: ResOperand

x: CellRef

y: CellRef

Finds some x and y such that x * scalar + y = value and x <= max_x.

AllocFelt252Dict

Fields

segment_arena_ptr: ResOperand

Allocates a new dict segment, and write its start address into the dict_infos segment.

Felt252DictRead

Fields

dict_ptr: ResOperand

key: ResOperand

value_dst: CellRef

Retrieves and writes the value corresponding to the given dict and key from the vm dict_manager.

Felt252DictWrite

Fields

dict_ptr: ResOperand

key: ResOperand

value: ResOperand

Sets the value corresponding to the key in the vm dict_manager.

GetSegmentArenaIndex

Fields

dict_end_ptr: ResOperand

dict_index: CellRef

Retrieves the index of the given dict in the dict_infos segment.

InitSquashData

Fields

dict_accesses: ResOperand

ptr_diff: ResOperand

n_accesses: ResOperand

big_keys: CellRef

first_key: CellRef

Initialized the lists of accesses of each key of a dict as a preparation of squash_dict.

GetCurrentAccessIndex

Fields

range_check_ptr: ResOperand

Retrieves the current index of a dict access to process.

ShouldSkipSquashLoop

Fields

should_skip_loop: CellRef

Writes if the squash_dict loop should be skipped.

GetCurrentAccessDelta

Fields

index_delta_minus1: CellRef

Writes the delta from the current access index to the next one.

ShouldContinueSquashLoop

Fields

should_continue: CellRef

Writes if the squash_dict loop should be continued.

AssertCurrentAccessIndicesIsEmpty

Asserts that the current access indices list is empty (after the loop).

AssertAllAccessesUsed

Fields

n_used_accesses: CellRef

Asserts that the number of used accesses is equal to the length of the original accesses list.

AssertAllKeysUsed

Asserts that the keys list is empty.

GetNextDictKey

Fields

next_key: CellRef

Writes the next dict key to process.

AssertLtAssertValidInput

Fields

a: ResOperand

b: ResOperand

Asserts that the input represents integers and that a<b.

AssertLeFindSmallArcs

Fields

range_check_ptr: ResOperand

a: ResOperand

b: ResOperand

Finds the two small arcs from within [(0,a),(a,b),(b,PRIME)] and writes it to the range_check segment.

AssertLeIsFirstArcExcluded

Fields

skip_exclude_a_flag: CellRef

Writes if the arc (0,a) was excluded.

AssertLeIsSecondArcExcluded

Fields

skip_exclude_b_minus_a: CellRef

Writes if the arc (a,b) was excluded.

AssertLeAssertThirdArcExcluded

Asserts that the arc (b, PRIME) was excluded.

RandomEcPoint

Fields

x: CellRef

y: CellRef

Samples a random point on the EC.

FieldSqrt

Fields

val: ResOperand

sqrt: CellRef

Computes the square root of val, if val is a quadratic residue, and of 3 * val otherwise.

Since 3 is not a quadratic residue, exactly one of val and 3 * val is a quadratic residue (unless val is 0). This allows proving that val is not a quadratic residue.

SystemCall

Fields

system: ResOperand

Represents a hint that triggers a system call.

DebugPrint

Fields

start: ResOperand

end: ResOperand

Prints the values from start to end. Both must be pointers.

AllocConstantSize

Fields

size: ResOperand

dst: CellRef

Returns an address with size free locations afterwards.

SetBlockNumber

Fields

value: ResOperand

SetBlockTimestamp

Fields

value: ResOperand

SetCallerAddress

Fields

value: ResOperand

SetContractAddress

Fields

value: ResOperand

SetSequencerAddress

Fields

value: ResOperand

Trait Implementations

impl Clone for Hint

fn clone(&self) -> Hint

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Hint

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Hint

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

Deserialize this value from the given Serde deserializer.

impl Display for Hint

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

Formats the value using the given formatter.

impl PartialEq<Hint> for Hint

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Hint

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 Hint

impl StructuralEq for Hint

impl StructuralPartialEq for Hint