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

@@ -18,6 +18,7 @@ use starknet_api::transaction::{
     MessageToL1 as StarknetAPIMessageToL1,
 };
 use starknet_types_core::felt::Felt;
+use strum::{AsRefStr, Display, EnumString};
 
 use crate::blockifier_versioned_constants::VersionedConstants;
 use crate::execution::contract_class::TrackedResource;
@@ -273,11 +274,18 @@ impl AddAssign<&ChargedResources> for ChargedResources {
 }
 
 #[cfg_attr(feature = "transaction_serde", derive(serde::Deserialize))]
-#[derive(Clone, Debug, Eq, Hash, PartialEq, Serialize, Ord, PartialOrd)]
+#[derive(
+    Clone, Debug, Eq, Hash, PartialEq, Serialize, Ord, PartialOrd, Display, EnumString, AsRefStr,
+)]
+#[strum(serialize_all = "snake_case")]
 pub enum OpcodeName {
     Blake,
 }
 
+/// Error type for parsing [`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 +296,36 @@ pub enum CairoPrimitiveName {
     Opcode(OpcodeName),
 }
 
+impl CairoPrimitiveName {
+    pub fn to_str(&self) -> &str {
+        match self {
+            Self::Builtin(builtin) => builtin.to_str(),
+            Self::Opcode(opcode) => opcode.as_ref(),
+        }
+    }
+}
+
+impl std::fmt::Display for CairoPrimitiveName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Builtin(builtin) => write!(f, "{builtin}"),
+            Self::Opcode(opcode) => write!(f, "{opcode}"),
+        }
+    }
+}
+
+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(Self::Builtin(builtin));
+        }
+        s.parse::<OpcodeName>().map(Self::Opcode).map_err(|_| ParseCairoPrimitiveNameError)
+    }
+}
+
 impl From<BuiltinName> for CairoPrimitiveName {
     fn from(builtin_name: BuiltinName) -> Self {
         CairoPrimitiveName::Builtin(builtin_name)