chore(blockifier): share the utility felt_to_u128 to starknet api

crates/blockifier/src/abi/sierra_types.rs

@@ -3,26 +3,18 @@ use cairo_vm::types::relocatable::Relocatable;
 use cairo_vm::vm::errors::memory_errors::MemoryError;
 use cairo_vm::vm::vm_core::VirtualMachine;
 use num_bigint::{BigUint, ToBigUint};
-use num_traits::ToPrimitive;
-use starknet_api::core::ContractAddress;
+use starknet_api::core::{felt_to_u128, ContractAddress};
 use starknet_api::state::StorageKey;
 use starknet_api::StarknetApiError;
-use starknet_types_core::felt::Felt;
 use thiserror::Error;
 
 use crate::state::errors::StateError;
 use crate::state::state_api::StateReader;
 
-#[cfg(test)]
-#[path = "sierra_types_test.rs"]
-mod test;
-
 pub type SierraTypeResult<T> = Result<T, SierraTypeError>;
 
 #[derive(Debug, Error)]
 pub enum SierraTypeError {
-    #[error("Felt {val} is too big to convert to '{ty}'.")]
-    ValueTooLargeForType { val: Felt, ty: &'static str },
     #[error(transparent)]
     MemoryError(#[from] MemoryError),
     #[error(transparent)]
@@ -43,12 +35,6 @@ pub trait SierraType: Sized {
     ) -> SierraTypeResult<Self>;
 }
 
-// Utils.
-
-fn felt_to_u128(felt: &Felt) -> Result<u128, SierraTypeError> {
-    felt.to_u128().ok_or(SierraTypeError::ValueTooLargeForType { val: *felt, ty: "u128" })
-}
-
 // Implementations.
 
 // We implement the trait SierraType for SierraU128 and not for u128 since it's not guaranteed that

crates/starknet_api/Cargo.toml

@@ -18,6 +18,7 @@ hex.workspace = true
 indexmap = { workspace = true, features = ["serde"] }
 itertools.workspace = true
 num-bigint.workspace = true
+num-traits.workspace = true
 pretty_assertions.workspace = true
 primitive-types = { workspace = true, features = ["serde"] }
 serde = { workspace = true, features = ["derive", "rc"] }

crates/starknet_api/src/core.rs

@@ -5,6 +5,7 @@ mod core_test;
 use std::fmt::Debug;
 use std::sync::LazyLock;
 
+use num_traits::ToPrimitive;
 use primitive_types::H160;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use starknet_types_core::felt::{Felt, NonZeroFelt};
@@ -23,6 +24,12 @@ pub fn ascii_as_felt(ascii_str: &str) -> Result<Felt, StarknetApiError> {
     })
 }
 
+pub fn felt_to_u128(felt: &Felt) -> Result<u128, StarknetApiError> {
+    felt.to_u128().ok_or(StarknetApiError::OutOfRange {
+        string: format!("Felt {} is too big to convert to 'u128'", *felt,),
+    })
+}
+
 /// A chain id.
 #[derive(Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]
 pub enum ChainId {

crates/starknet_api/src/core_test.rs

@@ -1,10 +1,12 @@
 use assert_matches::assert_matches;
+use num_bigint::BigUint;
 use starknet_types_core::felt::Felt;
 use starknet_types_core::hash::{Pedersen, StarkHash as CoreStarkHash};
 
 use crate::core::{
     ascii_as_felt,
     calculate_contract_address,
+    felt_to_u128,
     ChainId,
     ContractAddress,
     EthAddress,
@@ -111,3 +113,21 @@ fn test_ascii_as_felt() {
     let expected_sn_main = Felt::from(23448594291968334_u128);
     assert_eq!(sn_main_felt, expected_sn_main);
 }
+
+#[test]
+fn test_value_too_large_for_type() {
+    // Happy flow.
+    let n = 1991_u128;
+    let n_as_felt = Felt::from(n);
+    felt_to_u128(&n_as_felt).unwrap();
+
+    // Value too large for type.
+    let overflowed_u128: BigUint = BigUint::from(1_u8) << 128;
+    let overflowed_u128_as_felt = Felt::from(overflowed_u128);
+    let error = felt_to_u128(&overflowed_u128_as_felt).unwrap_err();
+    assert_eq!(
+        format!("{error}"),
+        "Out of range Felt 340282366920938463463374607431768211456 is too big to convert to \
+         'u128'."
+    );
+}