cairo-vm 2.0.1

Blazing fast Cairo interpreter
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
114
115
116
117
118
119
120
121
122
123
124

use core::fmt::{Debug, Formatter};

use crate::Felt252;
use num_traits::ToPrimitive;

use crate::hint_processor::builtin_hint_processor::dict_manager::Dictionary;
use crate::hint_processor::builtin_hint_processor::hint_utils::{
    get_integer_from_var_name, get_ptr_from_var_name,
};
use crate::serde::deserialize_program::ApTracking;
use crate::stdlib::collections::HashMap;

use crate::types::exec_scope::ExecutionScopes;
use crate::types::relocatable::MaybeRelocatable;
use crate::vm::errors::hint_errors::HintError;
use crate::{
    hint_processor::hint_processor_definition::HintReference, vm::vm_core::VirtualMachine,
};

pub fn print_felt(
    vm: &VirtualMachine,
    ids_data: &HashMap<String, HintReference>,
    ap_tracking: &ApTracking,
) -> Result<(), HintError> {
    let val = get_integer_from_var_name("x", vm, ids_data, ap_tracking)?;
    println!("{val}");
    Ok(())
}

fn print_name(
    vm: &VirtualMachine,
    ids_data: &HashMap<String, HintReference>,
    ap_tracking: &ApTracking,
) -> Result<(), HintError> {
    let name = get_integer_from_var_name("name", vm, ids_data, ap_tracking)?;
    let name = String::from_utf8(name.as_ref().to_bigint().to_signed_bytes_be())
        .map_err(|err| HintError::CustomHint(err.to_string().into_boxed_str()))?;
    println!("{name}");
    Ok(())
}

pub fn print_array(
    vm: &VirtualMachine,
    ids_data: &HashMap<String, HintReference>,
    ap_tracking: &ApTracking,
) -> Result<(), HintError> {
    print_name(vm, ids_data, ap_tracking)?;

    let mut acc = Vec::new();
    let arr = get_ptr_from_var_name("arr", vm, ids_data, ap_tracking)?;
    let arr_len = get_integer_from_var_name("arr_len", vm, ids_data, ap_tracking)?;
    let arr_len = arr_len.to_usize().ok_or_else(|| {
        HintError::CustomHint(String::from("arr_len must be a positive integer").into_boxed_str())
    })?;
    for i in 0..arr_len {
        let val = vm.get_integer((arr + i)?)?;
        acc.push(val);
    }
    println!("{:?}", acc);
    Ok(())
}

enum DictValue {
    Int(Felt252),
    Relocatable(Vec<Felt252>),
}

impl Debug for DictValue {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::Int(int) => write!(f, "{:?}", int),
            Self::Relocatable(relocatable) => write!(f, "{:?}", relocatable),
        }
    }
}

pub fn print_dict(
    vm: &VirtualMachine,
    exec_scopes: &ExecutionScopes,
    ids_data: &HashMap<String, HintReference>,
    ap_tracking: &ApTracking,
) -> Result<(), HintError> {
    print_name(vm, ids_data, ap_tracking)?;

    let dict_ptr = get_ptr_from_var_name("dict_ptr", vm, ids_data, ap_tracking)?;
    let pointer_size = get_integer_from_var_name("pointer_size", vm, ids_data, ap_tracking)?;
    let pointer_size = pointer_size.to_usize().ok_or_else(|| {
        HintError::CustomHint(
            String::from("pointer_size must be a positive integer").into_boxed_str(),
        )
    })?;

    let dict_manager = exec_scopes.get_dict_manager()?;
    let dict_manager = dict_manager.borrow();
    let tracker = dict_manager.get_tracker(dict_ptr)?;

    let map = match &tracker.data {
        Dictionary::SimpleDictionary(dict) => dict,
        Dictionary::DefaultDictionary { dict, .. } => dict,
    };

    let mut acc = HashMap::new();
    for (k, v) in map.iter() {
        let key = k.get_int_ref().ok_or_else(|| {
            HintError::CustomHint(String::from("Expected felt key for dict").into_boxed_str())
        })?;
        match v {
            MaybeRelocatable::Int(value) => {
                acc.insert(key, DictValue::Int(*value));
            }
            MaybeRelocatable::RelocatableValue(val) => {
                let mut structure = Vec::new();
                for i in 0..pointer_size {
                    let val = *vm.get_integer((*val + i)?)?.as_ref();
                    structure.push(val);
                }
                acc.insert(key, DictValue::Relocatable(structure));
            }
        }
    }

    println!("{:?}", acc);
    Ok(())
}