feat(starknet_os): os_logger: implement ResourceCounter::new

Author: dorimedini-starkware

crates/starknet_os/src/hint_processor/os_logger.rs

@@ -2,15 +2,33 @@ use std::collections::HashMap;
 
 use blockifier::execution::syscalls::SyscallSelector;
 use blockifier::transaction::transaction_types::TransactionType;
+use cairo_vm::hint_processor::hint_processor_definition::HintReference;
+use cairo_vm::serde::deserialize_program::ApTracking;
+use cairo_vm::types::builtin_name::BuiltinName;
+use cairo_vm::types::program::Program;
+use cairo_vm::types::relocatable::Relocatable;
 use cairo_vm::vm::runners::cairo_runner::ExecutionResources;
+use cairo_vm::vm::vm_core::VirtualMachine;
 use starknet_api::transaction::TransactionHash;
 
+use crate::hints::error::OsHintError;
+use crate::hints::vars::{CairoStruct, Ids};
+use crate::vm_utils::get_address_of_nested_fields;
+
 #[derive(Debug, thiserror::Error)]
 pub enum OsLoggerError {
+    #[error("Failed to build builtin pointer map: {0}.")]
+    BuiltinPtrs(OsHintError),
     #[error("SyscallTrace should be finalized only once.")]
     DoubleFinalize,
+    #[error("Failed to fetch identifier data for struct {0}.")]
+    InnerBuiltinPtrsIdentifierMissing(String),
+    #[error("The `members` field is None in identifier data for struct {0}.")]
+    MissingMembers(String),
     #[error("SyscallTrace should be finalized before accessing resources.")]
     ResourceAccessBeforeFinalize,
+    #[error("{0}")]
+    UnknownBuiltin(String),
 }
 
 pub type OsLoggerResult<T> = Result<T, OsLoggerError>;
@@ -129,3 +147,101 @@ impl TryFrom<OsTransactionTrace> for String {
         ))
     }
 }
+
+#[allow(dead_code)]
+pub struct ResourceCounter {
+    n_steps: usize,
+    range_check_ptr: Relocatable,
+    builtin_ptrs_dict: HashMap<BuiltinName, Relocatable>,
+}
+
+impl ResourceCounter {
+    #[allow(dead_code)]
+    pub(crate) fn new(
+        n_steps: usize,
+        range_check_ptr: Relocatable,
+        ids_data: &HashMap<String, HintReference>,
+        vm: &VirtualMachine,
+        ap_tracking: &ApTracking,
+        os_program: &Program,
+    ) -> OsLoggerResult<Self> {
+        Ok(Self {
+            n_steps,
+            range_check_ptr,
+            builtin_ptrs_dict: Self::build_builtin_ptrs_dict(
+                ids_data,
+                vm,
+                ap_tracking,
+                os_program,
+            )?,
+        })
+    }
+
+    fn build_builtin_ptrs_dict(
+        ids_data: &HashMap<String, HintReference>,
+        vm: &VirtualMachine,
+        ap_tracking: &ApTracking,
+        os_program: &Program,
+    ) -> OsLoggerResult<HashMap<BuiltinName, Relocatable>> {
+        let mut builtin_ptrs_dict: HashMap<BuiltinName, Relocatable> = HashMap::new();
+
+        // The `BuiltinPointers` struct has two fields: selectable and non-selectable builtins.
+        Self::insert_builtins(true, &mut builtin_ptrs_dict, ids_data, vm, ap_tracking, os_program)?;
+        Self::insert_builtins(
+            false,
+            &mut builtin_ptrs_dict,
+            ids_data,
+            vm,
+            ap_tracking,
+            os_program,
+        )?;
+
+        Ok(builtin_ptrs_dict)
+    }
+
+    fn insert_builtins(
+        selectable: bool,
+        builtin_ptrs_dict: &mut HashMap<BuiltinName, Relocatable>,
+        ids_data: &HashMap<String, HintReference>,
+        vm: &VirtualMachine,
+        ap_tracking: &ApTracking,
+        os_program: &Program,
+    ) -> OsLoggerResult<()> {
+        let (inner_field_name, inner_struct) = if selectable {
+            ("selectable", CairoStruct::SelectableBuiltins)
+        } else {
+            ("non_selectable", CairoStruct::NonSelectableBuiltins)
+        };
+
+        // We want all pointers except `segment_arena` and `sha256`.
+        let inner_struct_name: &str = inner_struct.into();
+        let inner_members = os_program
+            .get_identifier(inner_struct_name)
+            .ok_or(OsLoggerError::InnerBuiltinPtrsIdentifierMissing(inner_struct_name.into()))?
+            .members
+            .as_ref()
+            .ok_or(OsLoggerError::MissingMembers(inner_struct_name.into()))?;
+
+        for member_name in inner_members.keys() {
+            if member_name == "segment_arena" || member_name == "sha256" {
+                continue;
+            }
+            let member_ptr = get_address_of_nested_fields(
+                ids_data,
+                Ids::BuiltinPtrs,
+                CairoStruct::BuiltinPointersPtr,
+                vm,
+                ap_tracking,
+                &[inner_field_name, member_name.as_str()],
+                os_program,
+            )
+            .map_err(OsLoggerError::BuiltinPtrs)?;
+            builtin_ptrs_dict.insert(
+                BuiltinName::from_str(member_name)
+                    .ok_or(OsLoggerError::UnknownBuiltin(member_name.clone()))?,
+                member_ptr,
+            );
+        }
+        Ok(())
+    }
+}

crates/starknet_os/src/hints/vars.rs

@@ -82,6 +82,7 @@ pub enum Ids {
     Bit,
     BucketIndex,
     BuiltinCosts,
+    BuiltinPtrs,
     CompiledClass,
     CompiledClassFact,
     CompressedDst,
@@ -141,6 +142,7 @@ impl From<Ids> for &'static str {
             Ids::Bit => "bit",
             Ids::BucketIndex => "bucket_index",
             Ids::BuiltinCosts => "builtin_costs",
+            Ids::BuiltinPtrs => "builtin_ptrs",
             Ids::CompiledClass => "compiled_class",
             Ids::CompiledClassFact => "compiled_class_fact",
             Ids::CompressedDst => "compressed_dst",
@@ -285,6 +287,7 @@ impl Const {
 #[derive(Copy, Clone)]
 pub enum CairoStruct {
     BigInt3,
+    BuiltinPointersPtr,
     CompiledClass,
     CompiledClassEntryPoint,
     CompiledClassFact,
@@ -294,8 +297,10 @@ pub enum CairoStruct {
     DictAccess,
     ExecutionContext,
     NodeEdge,
+    NonSelectableBuiltins,
     OsStateUpdate,
     ResourceBounds,
+    SelectableBuiltins,
     StateEntry,
     StorageReadPtr,
     StorageReadRequestPtr,
@@ -308,6 +313,9 @@ impl From<CairoStruct> for &'static str {
             CairoStruct::BigInt3 => {
                 "starkware.starknet.core.os.data_availability.bls_field.BigInt3"
             }
+            CairoStruct::BuiltinPointersPtr => {
+                "starkware.starknet.core.os.builtins.BuiltinPointers*"
+            }
             CairoStruct::CompiledClass => {
                 "starkware.starknet.core.os.contract_class.compiled_class.CompiledClass"
             }
@@ -334,8 +342,14 @@ impl From<CairoStruct> for &'static str {
                 "starkware.starknet.core.os.execution.execute_entry_point.ExecutionContext"
             }
             CairoStruct::NodeEdge => "starkware.cairo.common.patricia_utils.NodeEdge",
+            CairoStruct::NonSelectableBuiltins => {
+                "starkware.starknet.core.os.builtins.NonSelectableBuiltins"
+            }
             CairoStruct::OsStateUpdate => "starkware.starknet.core.os.state.state.OsStateUpdate",
             CairoStruct::ResourceBounds => "starkware.starknet.common.new_syscalls.ResourceBounds",
+            CairoStruct::SelectableBuiltins => {
+                "starkware.starknet.core.os.builtins.SelectableBuiltins"
+            }
             CairoStruct::StateEntry => "starkware.starknet.core.os.state.state.StateEntry",
             CairoStruct::StorageReadPtr => "starkware.starknet.common.syscalls.StorageRead*",
             CairoStruct::StorageReadRequestPtr => {