cairo-lang-sierra 2.19.2

Sierra representation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::define_libfunc_hierarchy;
use crate::extensions::lib_func::{
    BranchSignature, DeferredOutputKind, LibfuncSignature, OutputVarInfo, ParamSignature,
    SierraApChange, SignatureSpecializationContext,
};
use crate::extensions::modules::gas::GasBuiltinType;
use crate::extensions::modules::int::unsigned128::Uint128Type;
use crate::extensions::modules::range_check::RangeCheckType;
use crate::extensions::{
    NamedType, NoGenericArgsGenericLibfunc, NoGenericArgsGenericType, OutputVarReferenceInfo,
    SpecializationError,
};
use crate::ids::GenericTypeId;

/// Represents a gas reserve.
///
/// Gas reserves can be created at any point using gas from the gas counter,
/// and can be utilized at a later point in time.
#[derive(Default)]
pub struct GasReserveType {}
impl NoGenericArgsGenericType for GasReserveType {
    const ID: GenericTypeId = GenericTypeId::new_inline("GasReserve");
    const STORABLE: bool = true;
    const DUPLICATABLE: bool = false;
    const DROPPABLE: bool = true;
    const ZERO_SIZED: bool = false;
}

define_libfunc_hierarchy! {
    pub enum GasReserveLibfunc {
        Create(GasReserveCreateLibfunc),
        Utilize(GasReserveUtilizeLibfunc),
    }, GasReserveConcreteLibfunc
}

/// Libfunc for creating a gas reserve.
#[derive(Default)]
pub struct GasReserveCreateLibfunc {}
impl NoGenericArgsGenericLibfunc for GasReserveCreateLibfunc {
    const STR_ID: &'static str = "gas_reserve_create";

    fn specialize_signature(
        &self,
        context: &dyn SignatureSpecializationContext,
    ) -> Result<LibfuncSignature, SpecializationError> {
        let gas_builtin_type = context.get_concrete_type(GasBuiltinType::id(), &[])?;
        let range_check_type = context.get_concrete_type(RangeCheckType::id(), &[])?;
        let u128_type = context.get_concrete_type(Uint128Type::id(), &[])?;
        let gas_reserve_type = context.get_concrete_type(GasReserveType::id(), &[])?;

        let rc_output_info = OutputVarInfo::new_builtin(range_check_type.clone());
        Ok(LibfuncSignature {
            param_signatures: vec![
                ParamSignature::new(range_check_type).with_allow_add_const(),
                ParamSignature::new(gas_builtin_type.clone()),
                ParamSignature::new(u128_type),
            ],
            branch_signatures: vec![
                // Success.
                BranchSignature {
                    vars: vec![
                        rc_output_info.clone(),
                        OutputVarInfo {
                            ty: gas_builtin_type.clone(),
                            ref_info: OutputVarReferenceInfo::NewTempVar { idx: 0 },
                        },
                        OutputVarInfo {
                            ty: gas_reserve_type,
                            ref_info: OutputVarReferenceInfo::SameAsParam { param_idx: 2 },
                        },
                    ],
                    ap_change: SierraApChange::Known { new_vars_only: false },
                },
                // Failure.
                BranchSignature {
                    vars: vec![
                        rc_output_info,
                        OutputVarInfo {
                            ty: gas_builtin_type,
                            ref_info: OutputVarReferenceInfo::SameAsParam { param_idx: 1 },
                        },
                    ],
                    ap_change: SierraApChange::Known { new_vars_only: false },
                },
            ],
            fallthrough: Some(0),
        })
    }
}

/// Libfunc for redepositing a gas reserve back into the gas counter.
#[derive(Default)]
pub struct GasReserveUtilizeLibfunc {}
impl NoGenericArgsGenericLibfunc for GasReserveUtilizeLibfunc {
    const STR_ID: &'static str = "gas_reserve_utilize";

    fn specialize_signature(
        &self,
        context: &dyn SignatureSpecializationContext,
    ) -> Result<LibfuncSignature, SpecializationError> {
        let gas_builtin_type = context.get_concrete_type(GasBuiltinType::id(), &[])?;
        let gas_reserve_type = context.get_concrete_type(GasReserveType::id(), &[])?;

        Ok(LibfuncSignature::new_non_branch(
            vec![gas_builtin_type.clone(), gas_reserve_type],
            vec![OutputVarInfo {
                ty: gas_builtin_type,
                ref_info: OutputVarReferenceInfo::Deferred(DeferredOutputKind::Generic),
            }],
            SierraApChange::Known { new_vars_only: true },
        ))
    }
}