blockifier: enable getting cairo_primitive gas cost by name

Author: avivg-starkware

crates/blockifier/src/blockifier_versioned_constants.rs

@@ -24,6 +24,7 @@ use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
 use strum::IntoEnumIterator;
 use thiserror::Error;
 
+use crate::execution::call_info::{CairoPrimitiveName, OpcodeName};
 use crate::execution::common_hints::ExecutionMode;
 use crate::execution::execution_utils::poseidon_hash_many_cost;
 use crate::execution::syscalls::vm_syscall_utils::{SyscallSelector, SyscallUsageMap};
@@ -926,6 +927,7 @@ pub struct BaseGasCosts {
 }
 
 #[derive(Clone, Copy, Debug, Default, Deserialize, PartialEq, Serialize)]
+// TODO(AvivG): Consider renaming to CairoPrimitiveGasCosts to match with its usage in the bouncer.
 pub struct BuiltinGasCosts {
     // Range check has a hard-coded cost higher than its proof percentage to avoid the overhead of
     // retrieving its price from the table.
@@ -965,6 +967,23 @@ impl BuiltinGasCosts {
 
         Ok(gas_cost)
     }
+
+    pub fn get_opcode_gas_cost(&self, opcode: &OpcodeName) -> u64 {
+        match opcode {
+            OpcodeName::Blake => self.blake,
+        }
+    }
+
+    /// Returns the gas cost for any Cairo primitive (builtin or opcode).
+    pub fn get_cairo_primitive_gas_cost(
+        &self,
+        primitive: &CairoPrimitiveName,
+    ) -> Result<u64, GasCostsError> {
+        match primitive {
+            CairoPrimitiveName::Builtin(builtin) => self.get_builtin_gas_cost(builtin),
+            CairoPrimitiveName::Opcode(opcode) => Ok(self.get_opcode_gas_cost(opcode)),
+        }
+    }
 }
 
 /// Gas cost constants. For more documentation see in core/os/constants.cairo.

crates/blockifier/src/execution/call_info.rs

@@ -272,12 +272,45 @@ impl AddAssign<&ChargedResources> for ChargedResources {
     }
 }
 
+// Opcode name constants.
+const BLAKE_OPCODE_NAME: &str = "blake";
+
 #[cfg_attr(feature = "transaction_serde", derive(serde::Deserialize))]
 #[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Ord, PartialOrd)]
 pub enum OpcodeName {
     Blake,
 }
 
+impl OpcodeName {
+    /// Converts an [`OpcodeName`] to its string representation.
+    pub fn to_str(&self) -> &'static str {
+        match self {
+            OpcodeName::Blake => BLAKE_OPCODE_NAME,
+        }
+    }
+}
+
+impl std::fmt::Display for OpcodeName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.to_str())
+    }
+}
+
+impl std::str::FromStr for OpcodeName {
+    type Err = ParseCairoPrimitiveNameError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            BLAKE_OPCODE_NAME => Ok(OpcodeName::Blake),
+            _ => Err(ParseCairoPrimitiveNameError),
+        }
+    }
+}
+
+/// Error type for parsing [`OpcodeName`] or [`CairoPrimitiveName`] from a string.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ParseCairoPrimitiveNameError;
+
 #[cfg_attr(feature = "transaction_serde", derive(serde::Deserialize))]
 #[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Ord, PartialOrd)]
 // Serialize as an untagged enum to avoid a type prefix, for backward compatibility with
@@ -288,6 +321,31 @@ pub enum CairoPrimitiveName {
     Opcode(OpcodeName),
 }
 
+impl CairoPrimitiveName {
+    /// Converts a [`CairoPrimitiveName`] to its string representation.
+    pub fn to_str(&self) -> &'static str {
+        match self {
+            CairoPrimitiveName::Builtin(builtin) => builtin.to_str(),
+            CairoPrimitiveName::Opcode(opcode) => opcode.to_str(),
+        }
+    }
+}
+
+impl std::str::FromStr for CairoPrimitiveName {
+    type Err = ParseCairoPrimitiveNameError;
+
+    /// Tries to parse as a builtin first, then as an opcode.
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Some(builtin) = BuiltinName::from_str(s) {
+            return Ok(CairoPrimitiveName::Builtin(builtin));
+        }
+        if let Ok(opcode) = s.parse::<OpcodeName>() {
+            return Ok(CairoPrimitiveName::Opcode(opcode));
+        }
+        Err(ParseCairoPrimitiveNameError)
+    }
+}
+
 impl From<BuiltinName> for CairoPrimitiveName {
     fn from(builtin_name: BuiltinName) -> Self {
         CairoPrimitiveName::Builtin(builtin_name)
@@ -300,6 +358,12 @@ impl From<OpcodeName> for CairoPrimitiveName {
     }
 }
 
+impl std::fmt::Display for CairoPrimitiveName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.to_str())
+    }
+}
+
 pub type CairoPrimitiveCounterMap = BTreeMap<CairoPrimitiveName, usize>;
 
 pub type BuiltinCounterMap = BTreeMap<BuiltinName, usize>;