repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/constants.rs | crates/starknet-devnet-types/src/constants.rs | use starknet_rs_core::types::Felt;
// copied from starknet-rs, because it is not exposed as public type
pub const QUERY_VERSION_OFFSET: Felt =
Felt::from_raw([576460752142434320, 18446744073709551584, 17407, 18446744073700081665]);
/// Cairo string for "l1_handler"
pub(crate) const PREFIX_L1_HANDLER: Felt = Felt::from_raw([
157895833347907735,
18446744073709551615,
18446744073708665300,
1365666230910873368,
]);
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/serde_helpers.rs | crates/starknet-devnet-types/src/serde_helpers.rs | pub mod rpc_sierra_contract_class_to_sierra_contract_class {
use serde::{Deserialize, Deserializer};
pub fn deserialize_to_sierra_contract_class<'de, D>(
deserializer: D,
) -> Result<cairo_lang_starknet_classes::contract_class::ContractClass, D::Error>
where
D: Deserializer<'de>,
{
let mut json_obj = serde_json::Value::deserialize(deserializer)?;
// Take the inner part of the string value which is expected to be a JSON array and replace
// it with the deserialized value.
// If for some reason the abi field is empty string, remove it from collection
if let Some(serde_json::Value::String(abi_string)) = json_obj.get("abi") {
if !abi_string.is_empty() {
let arr: serde_json::Value =
serde_json::from_str(abi_string).map_err(serde::de::Error::custom)?;
json_obj
.as_object_mut()
.ok_or(serde::de::Error::custom("Expected to be an object"))?
.insert("abi".to_string(), arr);
} else {
json_obj
.as_object_mut()
.ok_or(serde::de::Error::custom("Expected to be an object"))?
.remove("abi");
}
};
serde_json::from_value(json_obj).map_err(serde::de::Error::custom)
}
#[cfg(test)]
mod tests {
use serde::Deserialize;
use crate::serde_helpers::rpc_sierra_contract_class_to_sierra_contract_class::deserialize_to_sierra_contract_class;
#[test]
fn correct_deserialization_from_sierra_contract_class_with_abi_field_as_string() {
#[derive(Deserialize)]
struct TestDeserialization(
#[allow(unused)]
#[serde(deserialize_with = "deserialize_to_sierra_contract_class")]
cairo_lang_starknet_classes::contract_class::ContractClass,
);
let path = concat!(
env!("CARGO_MANIFEST_DIR"),
"/test_data/sierra_contract_class_with_abi_as_string.json"
);
let json_str = std::fs::read_to_string(path).unwrap();
serde_json::from_str::<TestDeserialization>(&json_str).unwrap();
}
}
}
pub mod hex_string {
use serde::{Deserialize, Deserializer, Serializer};
use starknet_rs_core::types::Felt;
use crate::contract_address::ContractAddress;
use crate::felt::felt_from_prefixed_hex;
use crate::patricia_key::PatriciaKey;
pub fn deserialize_to_prefixed_patricia_key<'de, D>(
deserializer: D,
) -> Result<PatriciaKey, D::Error>
where
D: Deserializer<'de>,
{
let felt = deserialize_prefixed_hex_string_to_felt(deserializer)?;
PatriciaKey::new(felt).map_err(serde::de::Error::custom)
}
pub fn deserialize_to_prefixed_contract_address<'de, D>(
deserializer: D,
) -> Result<ContractAddress, D::Error>
where
D: Deserializer<'de>,
{
let felt = deserialize_prefixed_hex_string_to_felt(deserializer)?;
ContractAddress::new(felt).map_err(serde::de::Error::custom)
}
pub fn serialize_patricia_key_to_prefixed_hex<S>(
patricia_key: &PatriciaKey,
s: S,
) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
s.serialize_str(&patricia_key.to_felt().to_hex_string())
}
pub fn serialize_contract_address_to_prefixed_hex<S>(
contract_address: &ContractAddress,
s: S,
) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serialize_patricia_key_to_prefixed_hex(&contract_address.0, s)
}
pub fn deserialize_prefixed_hex_string_to_felt<'de, D>(
deserializer: D,
) -> Result<Felt, D::Error>
where
D: Deserializer<'de>,
{
let buf = String::deserialize(deserializer)?;
felt_from_prefixed_hex(&buf).map_err(serde::de::Error::custom)
}
#[cfg(test)]
mod tests {
use serde::{Deserialize, Serialize};
use starknet_rs_core::types::Felt;
use crate::contract_address::ContractAddress;
use crate::felt::felt_from_prefixed_hex;
use crate::patricia_key::PatriciaKey;
use crate::serde_helpers::hex_string::{
deserialize_to_prefixed_contract_address, deserialize_to_prefixed_patricia_key,
serialize_contract_address_to_prefixed_hex,
};
#[test]
fn deserialization_of_prefixed_hex_patricia_key_should_be_successful() {
#[derive(Deserialize)]
struct TestDeserialization {
#[serde(deserialize_with = "deserialize_to_prefixed_patricia_key")]
data: PatriciaKey,
}
let json_str =
r#"{"data": "0x800000000000000000000000000000000000000000000000000000000000000"}"#;
let data = serde_json::from_str::<TestDeserialization>(json_str).unwrap();
assert!(
data.data.to_felt()
== felt_from_prefixed_hex(
"0x800000000000000000000000000000000000000000000000000000000000000"
)
.unwrap()
)
}
#[test]
fn deserialization_of_prefixed_hex_patricia_key_should_return_error() {
#[derive(Deserialize)]
struct TestDeserialization {
#[allow(unused)]
#[serde(deserialize_with = "deserialize_to_prefixed_patricia_key")]
data: PatriciaKey,
}
let json_str =
r#"{"data": "0x800000000000000000000000000000000000000000000000000000000000001"}"#;
assert!(serde_json::from_str::<TestDeserialization>(json_str).is_err())
}
#[test]
fn deserialization_of_prefixed_hex_contract_address_should_return_error() {
#[derive(Deserialize)]
struct TestDeserialization {
#[allow(unused)]
#[serde(deserialize_with = "deserialize_to_prefixed_contract_address")]
data: ContractAddress,
}
let json_str =
r#"{"data": "0x800000000000000000000000000000000000000000000000000000000000001"}"#;
assert!(serde_json::from_str::<TestDeserialization>(json_str).is_err())
}
#[test]
fn serialization_of_prefixed_hex_contract_address_should_be_correct() {
#[derive(Serialize)]
struct TestSerialization(
#[serde(serialize_with = "serialize_contract_address_to_prefixed_hex")]
ContractAddress,
);
let data = TestSerialization(ContractAddress::new(Felt::ONE).unwrap());
assert_eq!(serde_json::to_string(&data).unwrap(), r#""0x1""#);
}
}
}
pub mod dec_string {
use std::str::FromStr;
use bigdecimal::BigDecimal;
use num_bigint::BigUint;
use serde::Deserialize;
pub fn deserialize_biguint<'de, D>(deserializer: D) -> Result<BigUint, D::Error>
where
D: serde::Deserializer<'de>,
{
let number = serde_json::Number::deserialize(deserializer)?;
// biguint can't handle stringified scientific notation (that's what number can be)
let big_decimal =
BigDecimal::from_str(number.as_str()).map_err(serde::de::Error::custom)?;
// scale to 0 to force stringifying without scientific notation for large values (e.g. 1e30)
BigUint::from_str(&big_decimal.with_scale(0).to_string()).map_err(serde::de::Error::custom)
}
#[cfg(test)]
mod tests {
use num_bigint::BigUint;
use serde::Deserialize;
use crate::serde_helpers::dec_string::deserialize_biguint;
#[test]
fn deserialization_biguint() {
#[derive(Deserialize)]
struct TestDeserializationStruct {
#[serde(deserialize_with = "deserialize_biguint")]
value: BigUint,
}
for (json_str, expected) in [
(
r#"{"value": 3618502788666131106986593281521497120414687020801267626233049500247285301248}"#,
BigUint::from(1_u8) << 251,
),
(r#"{"value": 1000000000000000000000000000000}"#, BigUint::from(10_u8).pow(30)),
(
r#"{"value": 1000000000000000000000000000001}"#,
BigUint::from(10_u8).pow(30) + BigUint::from(1_u8),
),
(r#"{"value": 1e30}"#, BigUint::from(10_u8).pow(30)),
(r#"{"value": 1.23e1}"#, BigUint::from(12_u8)),
(r#"{"value": 1.29e1}"#, BigUint::from(12_u8)),
(r#"{"value": 100.0}"#, BigUint::from(100_u8)),
] {
match serde_json::from_str::<TestDeserializationStruct>(json_str) {
Ok(data) => assert_eq!(data.value, expected),
Err(e) => panic!("Unexpected response {e} for parsing: {json_str}"),
}
}
}
}
}
pub mod base_64_gzipped_json_string {
use base64::Engine;
use flate2::Compression;
use flate2::write::GzEncoder;
use serde::{Deserialize, Deserializer, Serializer};
use serde_json::Value;
use starknet_rs_core::serde::byte_array::base64 as base64Sir;
use starknet_rs_core::types::contract::legacy::LegacyProgram;
pub fn deserialize_to_serde_json_value_with_keys_ordered_in_alphabetical_order<'de, D>(
deserializer: D,
) -> Result<serde_json::Value, D::Error>
where
D: Deserializer<'de>,
{
let buf = String::deserialize(deserializer)?;
if buf.is_empty() {
return Ok(serde_json::Value::Null);
}
// TODO: change on starknet_rs_core::serde::byte_array::base64
let bytes = base64::engine::general_purpose::STANDARD
.decode(buf)
.map_err(|_| serde::de::Error::custom("program: Unable to decode base64 string"))?;
let decoder = flate2::read::GzDecoder::new(bytes.as_slice());
let starknet_program: LegacyProgram = serde_json::from_reader(decoder)
.map_err(|_| serde::de::Error::custom("program: Unable to decode gzipped bytes"))?;
serde_json::to_value(starknet_program)
.map_err(|_| serde::de::Error::custom("program: Unable to parse to JSON"))
}
pub fn serialize_program_to_base64<S>(program: &Value, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut buffer = Vec::new();
let encoder = GzEncoder::new(&mut buffer, Compression::best());
serde_json::to_writer(encoder, program)
.map_err(|_| serde::ser::Error::custom("program: Unable to encode program"))?;
base64Sir::serialize(&buffer, serializer)
}
#[cfg(test)]
mod tests {
use std::fs::File;
use serde::Deserialize;
use serde_json::json;
use crate::serde_helpers::base_64_gzipped_json_string::deserialize_to_serde_json_value_with_keys_ordered_in_alphabetical_order;
use crate::utils::test_utils::CAIRO_0_RPC_CONTRACT_PATH;
#[test]
fn deserialize_successfully_starknet_api_program() {
let json_value: serde_json::Value =
serde_json::from_reader(File::open(CAIRO_0_RPC_CONTRACT_PATH).unwrap()).unwrap();
#[derive(Deserialize)]
struct TestDeserialization {
#[allow(unused)]
#[serde(
deserialize_with = "deserialize_to_serde_json_value_with_keys_ordered_in_alphabetical_order"
)]
program: serde_json::Value,
}
serde_json::from_str::<TestDeserialization>(
&serde_json::to_string(&json!({ "program": json_value["program"]})).unwrap(),
)
.unwrap();
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/traits.rs | crates/starknet-devnet-types/src/traits.rs | use starknet_types_core::felt::Felt;
pub trait HashProducer {
type Error;
fn generate_hash(&self) -> Result<Felt, Self::Error>;
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/eth_address.rs | crates/starknet-devnet-types/src/rpc/eth_address.rs | use std::str::FromStr;
use starknet_api::core::{EthAddress as ApiEthAddress, L1Address};
use starknet_rs_core::types::{EthAddress, Felt};
use crate::error::{ConversionError, DevnetResult, Error};
use crate::{impl_wrapper_deserialize, impl_wrapper_serialize};
#[derive(Debug, Clone)]
pub struct EthAddressWrapper {
pub inner: EthAddress,
}
impl_wrapper_serialize!(EthAddressWrapper);
impl_wrapper_deserialize!(EthAddressWrapper, EthAddress);
impl FromStr for EthAddressWrapper {
type Err = Error;
fn from_str(s: &str) -> DevnetResult<Self> {
Ok(EthAddressWrapper { inner: EthAddress::from_str(s)? })
}
}
impl From<EthAddressWrapper> for Felt {
fn from(value: EthAddressWrapper) -> Self {
value.inner.into()
}
}
impl From<ApiEthAddress> for EthAddressWrapper {
fn from(value: ApiEthAddress) -> Self {
EthAddressWrapper { inner: EthAddress::from_bytes(value.0.to_fixed_bytes()) }
}
}
impl TryFrom<L1Address> for EthAddressWrapper {
type Error = Error;
fn try_from(value: L1Address) -> Result<Self, Self::Error> {
Ok(Self {
inner: EthAddress::from_felt(&value.0).map_err(|e| {
Error::ConversionError(ConversionError::OutOfRangeError(e.to_string()))
})?,
})
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/contract_class.rs | crates/starknet-devnet-types/src/rpc/contract_class.rs | use core::fmt::Debug;
use std::collections::HashMap;
use std::str::FromStr;
use std::sync::Arc;
use blockifier::execution::contract_class::{
CompiledClassV0, CompiledClassV0Inner, RunnableCompiledClass, deserialize_program,
};
use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
use cairo_lang_starknet_classes::contract_class::ContractClass as SierraContractClass;
use cairo_vm::types::errors::program_errors::ProgramError;
use deprecated::json_contract_class::Cairo0Json;
use serde::de::IntoDeserializer;
use serde::{Serialize, Serializer};
use starknet_api::contract_class::{ClassInfo, EntryPointType, SierraVersion};
use starknet_api::deprecated_contract_class::{EntryPointOffset, EntryPointV0};
use starknet_rs_core::types::contract::{SierraClass, SierraClassDebugInfo};
use starknet_rs_core::types::{
ContractClass as CodegenContractClass, FlattenedSierraClass as CodegenSierraContractClass,
LegacyContractEntryPoint,
};
use starknet_types_core::felt::Felt;
use crate::error::{ConversionError, DevnetResult, Error, JsonError};
use crate::serde_helpers::rpc_sierra_contract_class_to_sierra_contract_class::deserialize_to_sierra_contract_class;
use crate::traits::HashProducer;
use crate::utils::compile_sierra_contract;
pub mod deprecated;
pub use deprecated::Cairo0ContractClass;
#[derive(Debug, Clone)]
#[cfg_attr(feature = "testing", derive(Eq, PartialEq))]
#[allow(clippy::large_enum_variant)]
pub enum ContractClass {
Cairo0(Cairo0ContractClass),
Cairo1(SierraContractClass),
}
impl Serialize for ContractClass {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
ContractClass::Cairo0(cairo0) => cairo0.serialize(serializer),
ContractClass::Cairo1(contract) => contract.serialize(serializer),
}
}
}
impl ContractClass {
pub fn cairo_1_from_sierra_json_str(json_str: &str) -> DevnetResult<SierraContractClass> {
let sierra_contract_class: SierraContractClass =
serde_json::from_str(json_str).map_err(JsonError::SerdeJsonError)?;
Ok(sierra_contract_class)
}
}
impl From<Cairo0ContractClass> for ContractClass {
fn from(value: Cairo0ContractClass) -> Self {
ContractClass::Cairo0(value)
}
}
impl From<SierraContractClass> for ContractClass {
fn from(value: SierraContractClass) -> Self {
ContractClass::Cairo1(value)
}
}
impl From<Cairo0Json> for ContractClass {
fn from(value: Cairo0Json) -> Self {
ContractClass::Cairo0(value.into())
}
}
impl TryFrom<ContractClass> for SierraContractClass {
type Error = Error;
fn try_from(value: ContractClass) -> Result<Self, Self::Error> {
match value {
ContractClass::Cairo1(sierra) => Ok(sierra),
_ => Err(Error::ConversionError(crate::error::ConversionError::InvalidFormat)),
}
}
}
impl TryFrom<ContractClass> for Cairo0ContractClass {
type Error = Error;
fn try_from(value: ContractClass) -> Result<Self, Self::Error> {
match value {
ContractClass::Cairo0(cairo_0) => Ok(cairo_0),
_ => Err(Error::ConversionError(crate::error::ConversionError::InvalidFormat)),
}
}
}
impl TryFrom<ContractClass> for starknet_api::contract_class::ContractClass {
type Error = Error;
fn try_from(value: ContractClass) -> Result<Self, Self::Error> {
match value {
ContractClass::Cairo0(deprecated_contract_class) => {
Ok(starknet_api::contract_class::ContractClass::V0(
deprecated_contract_class.try_into()?,
))
}
ContractClass::Cairo1(sierra_contract_class) => {
let casm = compile_sierra_contract(&sierra_contract_class)?;
Ok(starknet_api::contract_class::ContractClass::V1((
casm,
SierraVersion::from_str(&sierra_contract_class.contract_class_version)?,
)))
}
}
}
}
impl TryFrom<ContractClass> for ClassInfo {
type Error = Error;
fn try_from(value: ContractClass) -> Result<Self, Self::Error> {
match value {
ContractClass::Cairo0(deprecated_contract_class) => {
// Set abi_length to 0 as per this conversation
// https://spaceshard.slack.com/archives/C03HL8DH52N/p1708512271256699?thread_ts=1707845482.455099&cid=C03HL8DH52N
let abi_length = 0;
ClassInfo::new(
&starknet_api::contract_class::ContractClass::V0(
deprecated_contract_class.try_into()?,
),
0,
abi_length,
SierraVersion::DEPRECATED,
)
.map_err(|e| {
Error::ConversionError(ConversionError::InvalidInternalStructure(e.to_string()))
})
}
ContractClass::Cairo1(sierra_contract_class) => {
let sierra_program_length = sierra_contract_class.sierra_program.len();
// Calculated as the length of the stringified abi
// https://spaceshard.slack.com/archives/C03HL8DH52N/p1708512271256699?thread_ts=1707845482.455099&cid=C03HL8DH52N
let abi_length = if let Some(abi) = sierra_contract_class.abi.as_ref() {
serde_json::to_string(abi)
.map(|json_str| json_str.len())
.map_err(|err| Error::JsonError(JsonError::SerdeJsonError(err)))?
} else {
0
};
let sierra_version =
SierraVersion::from_str(&sierra_contract_class.contract_class_version)?;
ClassInfo::new(
&ContractClass::Cairo1(sierra_contract_class).try_into()?,
sierra_program_length,
abi_length,
sierra_version,
)
.map_err(|e| {
Error::ConversionError(ConversionError::InvalidInternalStructure(e.to_string()))
})
}
}
}
}
impl HashProducer for ContractClass {
type Error = Error;
fn generate_hash(&self) -> DevnetResult<Felt> {
match self {
ContractClass::Cairo0(contract) => Ok(contract.generate_hash()?),
ContractClass::Cairo1(sierra) => {
let sierra_felt252_hash = compute_sierra_class_hash(sierra)?;
Ok(sierra_felt252_hash)
}
}
}
}
impl TryInto<CodegenContractClass> for ContractClass {
type Error = Error;
fn try_into(self) -> Result<CodegenContractClass, Self::Error> {
match self {
ContractClass::Cairo0(contract_class) => {
Ok(CodegenContractClass::Legacy(contract_class.try_into()?))
}
ContractClass::Cairo1(contract_class) => {
Ok(CodegenContractClass::Sierra(convert_sierra_to_codegen(&contract_class)?))
}
}
}
}
impl TryInto<ContractClass> for CodegenContractClass {
type Error = Error;
fn try_into(self) -> Result<ContractClass, Self::Error> {
let jsonified = serde_json::to_value(self.clone()).map_err(JsonError::SerdeJsonError)?;
Ok(match self {
CodegenContractClass::Sierra(_) => {
let devnet_class =
deserialize_to_sierra_contract_class(jsonified.into_deserializer())
.map_err(JsonError::SerdeJsonError)?;
ContractClass::Cairo1(devnet_class)
}
CodegenContractClass::Legacy(_) => ContractClass::Cairo0(
serde_json::from_value(jsonified).map_err(JsonError::SerdeJsonError)?,
),
})
}
}
impl TryFrom<ContractClass> for RunnableCompiledClass {
type Error = Error;
fn try_from(value: ContractClass) -> Result<Self, Self::Error> {
Ok(match value {
ContractClass::Cairo0(class) => class.try_into()?,
ContractClass::Cairo1(class) => {
let json_value = serde_json::to_value(&class).map_err(JsonError::SerdeJsonError)?;
jsonified_sierra_to_runnable_casm(json_value, &class.contract_class_version)?
}
})
}
}
impl TryFrom<Cairo0ContractClass> for RunnableCompiledClass {
type Error = Error;
fn try_from(class: Cairo0ContractClass) -> Result<Self, Self::Error> {
Ok(RunnableCompiledClass::V0(match class {
Cairo0ContractClass::RawJson(cairo0_json) => serde_json::from_value(cairo0_json.inner)
.map_err(|e| {
Error::ConversionError(ConversionError::InvalidInternalStructure(e.to_string()))
})?,
Cairo0ContractClass::Rpc(deprecated_contract_class) => {
let deserializer = deprecated_contract_class.program.into_deserializer();
let program = deserialize_program(deserializer).map_err(|e| {
Error::ConversionError(ConversionError::InvalidInternalStructure(e.to_string()))
})?;
fn convert_to_entrypoints_v0<'a, I>(entry_points: I) -> Vec<EntryPointV0>
where
I: Iterator<Item = &'a LegacyContractEntryPoint>,
{
entry_points
.map(|entry_point| EntryPointV0 {
selector: starknet_api::core::EntryPointSelector(entry_point.selector),
offset: EntryPointOffset(entry_point.offset as usize),
})
.collect()
}
let mut entry_points_by_type = HashMap::new();
entry_points_by_type.insert(
EntryPointType::Constructor,
convert_to_entrypoints_v0(
deprecated_contract_class.entry_points_by_type.constructor.iter(),
),
);
entry_points_by_type.insert(
EntryPointType::External,
convert_to_entrypoints_v0(
deprecated_contract_class.entry_points_by_type.external.iter(),
),
);
entry_points_by_type.insert(
EntryPointType::L1Handler,
convert_to_entrypoints_v0(
deprecated_contract_class.entry_points_by_type.l1_handler.iter(),
),
);
CompiledClassV0(Arc::new(CompiledClassV0Inner { program, entry_points_by_type }))
}
}))
}
}
fn convert_sierra_to_codegen(
contract_class: &SierraContractClass,
) -> DevnetResult<CodegenSierraContractClass> {
let abi = serde_json::to_string(&contract_class.abi).map_err(JsonError::SerdeJsonError)?;
let sierra_program = contract_class
.sierra_program
.iter()
.map(|bigint| Felt::from(bigint.value.clone()))
.collect::<Vec<_>>();
let entry_points_by_type_value =
serde_json::to_value(contract_class.entry_points_by_type.clone())
.map_err(JsonError::SerdeJsonError)?;
let entry_points_by_type =
serde_json::from_value(entry_points_by_type_value).map_err(JsonError::SerdeJsonError)?;
Ok(CodegenSierraContractClass {
sierra_program,
contract_class_version: contract_class.contract_class_version.clone(),
entry_points_by_type,
abi,
})
}
fn jsonified_sierra_to_runnable_casm(
jsonified_sierra: serde_json::Value,
sierra_version: &str,
) -> Result<RunnableCompiledClass, Error> {
let casm_json = usc::compile_contract(jsonified_sierra)
.map_err(|err| Error::SierraCompilationError { reason: err.to_string() })?;
let casm = serde_json::from_value::<CasmContractClass>(casm_json)
.map_err(|err| Error::JsonError(JsonError::Custom { msg: err.to_string() }))?;
let versioned_casm = (casm, SierraVersion::from_str(sierra_version)?);
let compiled = versioned_casm.try_into().map_err(|e: ProgramError| {
Error::ConversionError(ConversionError::InvalidInternalStructure(e.to_string()))
})?;
Ok(RunnableCompiledClass::V1(compiled))
}
pub fn convert_codegen_to_blockifier_compiled_class(
class: CodegenContractClass,
) -> Result<RunnableCompiledClass, Error> {
Ok(match &class {
CodegenContractClass::Sierra(sierra) => {
let json_value = serde_json::to_value(&class).map_err(JsonError::SerdeJsonError)?;
jsonified_sierra_to_runnable_casm(json_value, &sierra.contract_class_version)?
}
CodegenContractClass::Legacy(_) => {
let class_jsonified =
serde_json::to_string(&class).map_err(JsonError::SerdeJsonError)?;
let class: starknet_api::deprecated_contract_class::ContractClass =
serde_json::from_str(&class_jsonified)
.map_err(|e| Error::JsonError(JsonError::SerdeJsonError(e)))?;
let compiled = class.try_into().map_err(|e: ProgramError| {
Error::ConversionError(ConversionError::InvalidInternalStructure(e.to_string()))
})?;
RunnableCompiledClass::V0(compiled)
}
})
}
pub fn compute_sierra_class_hash(contract_class: &SierraContractClass) -> DevnetResult<Felt> {
let mut contract_class_json_value =
serde_json::to_value(contract_class).map_err(JsonError::SerdeJsonError)?;
// to match SierraClass struct, the field sierra_program_debug_info dont have to be
// Option::None, because during serialization it gets converted to null
// and the next deserialization to SierraClass will fail, because it expects this key to have
// some value
if contract_class.sierra_program_debug_info.is_none() {
contract_class_json_value["sierra_program_debug_info"] =
serde_json::to_value(SierraClassDebugInfo {
type_names: Default::default(),
libfunc_names: Default::default(),
user_func_names: Default::default(),
})
.map_err(JsonError::SerdeJsonError)?;
}
let sierra_class: SierraClass =
serde_json::from_value(contract_class_json_value).map_err(JsonError::SerdeJsonError)?;
sierra_class.class_hash().map_err(|_| Error::ConversionError(ConversionError::InvalidFormat))
}
#[cfg(test)]
mod tests {
use cairo_lang_starknet_classes::contract_class::ContractClass as SierraContractClass;
use serde::Deserialize;
use serde_json::Deserializer;
use starknet_rs_core::types::LegacyEntryPointsByType;
use crate::contract_class::deprecated::json_contract_class::Cairo0Json;
use crate::contract_class::deprecated::rpc_contract_class::{
ContractClassAbiEntryWithType, DeprecatedContractClass,
};
use crate::contract_class::{ContractClass, convert_sierra_to_codegen};
use crate::felt::felt_from_prefixed_hex;
use crate::serde_helpers::rpc_sierra_contract_class_to_sierra_contract_class::deserialize_to_sierra_contract_class;
use crate::traits::HashProducer;
use crate::utils::test_utils::{
CAIRO_0_ACCOUNT_CONTRACT_HASH, CAIRO_0_ACCOUNT_CONTRACT_PATH, CAIRO_1_CONTRACT_SIERRA_HASH,
CAIRO_1_EVENTS_CONTRACT_PATH,
};
#[test]
fn cairo_1_contract_class_hash_generated_successfully() {
let cairo_1_contract_sierra = ContractClass::Cairo1(
ContractClass::cairo_1_from_sierra_json_str(
&std::fs::read_to_string(CAIRO_1_EVENTS_CONTRACT_PATH).unwrap(),
)
.unwrap(),
);
assert_eq!(
felt_from_prefixed_hex(CAIRO_1_CONTRACT_SIERRA_HASH).unwrap(),
cairo_1_contract_sierra.generate_hash().unwrap()
);
}
#[test]
fn cairo_1_to_codegen() {
let path = concat!(
env!("CARGO_MANIFEST_DIR"),
"/test_data/sierra_contract_class_with_abi_as_string.json"
);
let contract_str = std::fs::read_to_string(path).unwrap();
let mut deserializer = Deserializer::from_str(&contract_str);
let contract_class: SierraContractClass =
deserialize_to_sierra_contract_class(&mut deserializer).unwrap();
convert_sierra_to_codegen(&contract_class).unwrap();
}
#[test]
fn cairo_0_contract_class_hash_generated_successfully() {
let json_str = std::fs::read_to_string(CAIRO_0_ACCOUNT_CONTRACT_PATH).unwrap();
let contract_class = Cairo0Json::raw_json_from_json_str(&json_str).unwrap();
let class_hash = contract_class.generate_hash().unwrap();
let expected_class_hash = felt_from_prefixed_hex(CAIRO_0_ACCOUNT_CONTRACT_HASH).unwrap();
assert_eq!(class_hash, expected_class_hash);
}
#[test]
fn contract_class_cairo_0_from_json_str_doesnt_accept_string_different_from_json() {
assert!(Cairo0Json::raw_json_from_json_str(" not JSON string").is_err());
}
/// The test takes a .casm artifact as raw json and generates its class hash.
/// Then it takes the same artifact as a `DeprecatedContractClass` and generates its class hash.
/// The test checks if both hashes are the same.
#[test]
fn cairo_0_contract_class_hash_generated_successfully_and_its_the_same_as_raw_json_contract_class_hash()
{
let contract_class = Cairo0Json::raw_json_from_path(
"../../contracts/test_artifacts/cairo0/ERC20_starknet_js.json",
)
.unwrap();
let class_hash = contract_class.generate_hash().unwrap();
// data taken from https://github.com/0xs34n/starknet.js/blob/ce57fdcaba61a8ef2382acc9233a9aac2ac8589a/__tests__/fixtures.ts#L126
let expected_class_hash = felt_from_prefixed_hex(
"0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a",
)
.unwrap();
assert_eq!(class_hash, expected_class_hash);
// this struct is for deserializing part of the raw json artifact
// because DeprecatedContractClass expects the program property to be gzipped then base64
// encoded we only take those params that dont have any special encoding
// Then to construct the `DeprecatedContractClass` we will assign the program property,
// instead of going through the process of gzipping and base64 encoding
#[derive(Deserialize)]
struct PartialDeprecatedContractClass {
pub abi: Vec<ContractClassAbiEntryWithType>,
/// The selector of each entry point is a unique identifier in the program.
pub entry_points_by_type: LegacyEntryPointsByType,
}
// first check if generated class hash is the same when constructing
// `DeprecatedContractClass` via assigning properties
let PartialDeprecatedContractClass { abi, entry_points_by_type } =
serde_json::from_value::<PartialDeprecatedContractClass>(contract_class.inner.clone())
.unwrap();
let program = contract_class.inner.get("program").unwrap();
let deprecated_contract_class =
DeprecatedContractClass { program: program.clone(), abi, entry_points_by_type };
assert_eq!(deprecated_contract_class.generate_hash().unwrap(), expected_class_hash);
// check if generated class hash is the same when deserializing to `DeprecatedContractClass`
let serialized_deprecated_contract_class =
serde_json::to_string(&deprecated_contract_class).unwrap();
assert_eq!(
DeprecatedContractClass::rpc_from_json_str(&serialized_deprecated_contract_class)
.unwrap()
.generate_hash()
.unwrap(),
expected_class_hash
);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/contract_address.rs | crates/starknet-devnet-types/src/rpc/contract_address.rs | use std::fmt::LowerHex;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use starknet_rs_core::types::Felt;
use crate::error::DevnetResult;
use crate::patricia_key::{PATRICIA_KEY_ZERO, PatriciaKey};
use crate::serde_helpers::hex_string::{
deserialize_to_prefixed_contract_address, serialize_contract_address_to_prefixed_hex,
};
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ContractAddress(pub(crate) PatriciaKey);
impl ContractAddress {
pub fn new(felt: Felt) -> DevnetResult<Self> {
Ok(Self(PatriciaKey::new(felt)?))
}
/// Constructs a ContractAddress without range checks.
/// Safety: `felt` must satisfy PatriciaKey bounds.
pub fn new_unchecked(felt: Felt) -> Self {
Self(PatriciaKey::new_unchecked(felt))
}
/// Constructs a zero address
pub fn zero() -> Self {
Self(PATRICIA_KEY_ZERO)
}
pub fn to_fixed_hex_string(&self) -> String {
self.0.0.to_fixed_hex_string()
}
}
impl Serialize for ContractAddress {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serialize_contract_address_to_prefixed_hex(self, serializer)
}
}
impl<'de> Deserialize<'de> for ContractAddress {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserialize_to_prefixed_contract_address(deserializer)
}
}
impl From<starknet_api::core::ContractAddress> for ContractAddress {
fn from(value: starknet_api::core::ContractAddress) -> Self {
Self(value.0.into())
}
}
impl From<ContractAddress> for starknet_api::core::ContractAddress {
fn from(value: ContractAddress) -> Self {
Self(value.0.into())
}
}
impl From<ContractAddress> for Felt {
fn from(value: ContractAddress) -> Self {
value.0.0
}
}
impl LowerHex for ContractAddress {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.0.0.to_hex_string().as_str())
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/transactions.rs | crates/starknet-devnet-types/src/rpc/transactions.rs | use std::sync::Arc;
use blockifier::blockifier_versioned_constants::VersionedConstants;
use blockifier::state::state_api::StateReader;
use blockifier::transaction::account_transaction::ExecutionFlags;
use blockifier::transaction::objects::TransactionExecutionInfo;
use deploy_transaction::DeployTransaction;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use starknet_api::block::{BlockNumber, GasPrice};
use starknet_api::contract_class::{ClassInfo, EntryPointType};
use starknet_api::core::calculate_contract_address;
use starknet_api::data_availability::DataAvailabilityMode;
use starknet_api::transaction::fields::{
AllResourceBounds, GasVectorComputationMode, Tip, ValidResourceBounds,
};
use starknet_api::transaction::{TransactionHasher, TransactionOptions, signed_tx_version};
use starknet_rs_core::types::{
EventsPage, ExecutionResult, Felt, ResourceBounds, ResourceBoundsMapping,
TransactionExecutionStatus,
};
use starknet_rs_core::utils::parse_cairo_short_string;
use self::broadcasted_declare_transaction_v3::BroadcastedDeclareTransactionV3;
use self::broadcasted_deploy_account_transaction_v3::BroadcastedDeployAccountTransactionV3;
use self::broadcasted_invoke_transaction_v3::BroadcastedInvokeTransactionV3;
use self::declare_transaction_v3::DeclareTransactionV3;
use self::deploy_account_transaction_v3::DeployAccountTransactionV3;
use self::invoke_transaction_v3::InvokeTransactionV3;
use self::l1_handler_transaction::L1HandlerTransaction;
use super::block::BlockId;
use super::estimate_message_fee::FeeEstimateWrapper;
use super::felt::BlockHash;
use super::messaging::{MessageToL1, OrderedMessageToL1};
use super::state::ThinStateDiff;
use super::transaction_receipt::{ExecutionResources, FeeInUnits, TransactionReceipt};
use crate::constants::QUERY_VERSION_OFFSET;
use crate::contract_address::ContractAddress;
use crate::contract_class::{ContractClass, compute_sierra_class_hash};
use crate::emitted_event::{Event, OrderedEvent};
use crate::error::{ConversionError, DevnetResult};
use crate::felt::{
Calldata, EntryPointSelector, Nonce, TransactionHash, TransactionSignature, TransactionVersion,
};
use crate::rpc::transaction_receipt::CommonTransactionReceipt;
use crate::{impl_wrapper_deserialize, impl_wrapper_serialize};
pub mod broadcasted_declare_transaction_v3;
pub mod broadcasted_deploy_account_transaction_v3;
pub mod broadcasted_invoke_transaction_v3;
pub mod declare_transaction_v3;
pub mod deploy_account_transaction_v3;
pub mod deploy_transaction;
pub mod invoke_transaction_v3;
pub mod l1_handler_transaction;
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize))]
#[serde(untagged)]
pub enum Transactions {
Hashes(Vec<TransactionHash>),
Full(Vec<TransactionWithHash>),
FullWithReceipts(Vec<TransactionWithReceipt>),
}
#[derive(Debug, Copy, Clone, Serialize, Default)]
#[cfg_attr(feature = "testing", derive(Deserialize))]
pub enum TransactionType {
#[serde(rename(deserialize = "DECLARE", serialize = "DECLARE"))]
Declare,
#[serde(rename(deserialize = "DEPLOY", serialize = "DEPLOY"))]
Deploy,
#[serde(rename(deserialize = "DEPLOY_ACCOUNT", serialize = "DEPLOY_ACCOUNT"))]
DeployAccount,
#[serde(rename(deserialize = "INVOKE", serialize = "INVOKE"))]
#[default]
Invoke,
#[serde(rename(deserialize = "L1_HANDLER", serialize = "L1_HANDLER"))]
L1Handler,
}
#[derive(Debug, Clone, Serialize)]
#[serde(tag = "type", rename_all = "SCREAMING_SNAKE_CASE")]
#[cfg_attr(feature = "testing", derive(Deserialize, PartialEq, Eq), serde(deny_unknown_fields))]
pub enum Transaction {
Declare(DeclareTransaction),
DeployAccount(DeployAccountTransaction),
Deploy(DeployTransaction),
Invoke(InvokeTransaction),
L1Handler(L1HandlerTransaction),
}
impl Transaction {
pub fn gas_vector_computation_mode(&self) -> GasVectorComputationMode {
match self {
Transaction::Declare(DeclareTransaction::V3(v3)) => v3.get_resource_bounds().into(),
Transaction::DeployAccount(DeployAccountTransaction::V3(v3)) => {
v3.get_resource_bounds().into()
}
Transaction::Invoke(InvokeTransaction::V3(v3)) => v3.get_resource_bounds().into(),
_ => GasVectorComputationMode::NoL2Gas,
}
}
pub fn get_sender_address(&self) -> Option<ContractAddress> {
match self {
Self::Declare(tx) => Some(tx.get_sender_address()),
Self::DeployAccount(tx) => Some(*tx.get_contract_address()),
Self::Deploy(_) => None,
Self::Invoke(tx) => Some(tx.get_sender_address()),
Self::L1Handler(tx) => Some(tx.contract_address),
}
}
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize, PartialEq, Eq))]
pub struct TransactionWithHash {
transaction_hash: TransactionHash,
#[serde(flatten)]
pub transaction: Transaction,
}
impl TransactionWithHash {
pub fn new(transaction_hash: TransactionHash, transaction: Transaction) -> Self {
Self { transaction_hash, transaction }
}
pub fn get_transaction_hash(&self) -> &TransactionHash {
&self.transaction_hash
}
pub fn get_type(&self) -> TransactionType {
match self.transaction {
Transaction::Declare(_) => TransactionType::Declare,
Transaction::DeployAccount(_) => TransactionType::DeployAccount,
Transaction::Deploy(_) => TransactionType::Deploy,
Transaction::Invoke(_) => TransactionType::Invoke,
Transaction::L1Handler(_) => TransactionType::L1Handler,
}
}
pub fn get_signature(&self) -> TransactionSignature {
match &self.transaction {
Transaction::Declare(DeclareTransaction::V3(tx)) => tx.signature.clone(),
Transaction::DeployAccount(DeployAccountTransaction::V3(tx)) => tx.signature.clone(),
Transaction::Invoke(InvokeTransaction::V3(tx)) => tx.signature.clone(),
_ => TransactionSignature::default(),
}
}
#[allow(clippy::too_many_arguments)]
pub fn create_common_receipt(
&self,
transaction_events: &[Event],
transaction_messages_sent: &[MessageToL1],
block_hash: Option<&BlockHash>,
block_number: Option<BlockNumber>,
execution_result: &ExecutionResult,
finality_status: TransactionFinalityStatus,
actual_fee: FeeInUnits,
execution_info: &TransactionExecutionInfo,
) -> CommonTransactionReceipt {
let r#type = self.get_type();
let execution_resources = ExecutionResources::from(execution_info);
CommonTransactionReceipt {
r#type,
transaction_hash: *self.get_transaction_hash(),
actual_fee,
messages_sent: transaction_messages_sent.to_vec(),
events: transaction_events.to_vec(),
execution_status: execution_result.clone(),
finality_status,
block_hash: block_hash.cloned(),
block_number,
execution_resources,
}
}
pub fn get_sender_address(&self) -> Option<ContractAddress> {
self.transaction.get_sender_address()
}
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize), serde(deny_unknown_fields))]
pub struct TransactionWithReceipt {
pub receipt: TransactionReceipt,
pub transaction: Transaction,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize, PartialEq, Eq))]
#[serde(deny_unknown_fields)]
pub struct TransactionStatus {
pub finality_status: TransactionFinalityStatus,
pub failure_reason: Option<String>,
pub execution_status: TransactionExecutionStatus,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize, PartialEq, Eq))]
#[serde(untagged)]
pub enum DeclareTransaction {
V3(DeclareTransactionV3),
}
impl DeclareTransaction {
pub fn get_sender_address(&self) -> ContractAddress {
match self {
DeclareTransaction::V3(tx) => tx.sender_address,
}
}
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize, PartialEq, Eq))]
#[serde(untagged)]
pub enum InvokeTransaction {
V3(InvokeTransactionV3),
}
impl InvokeTransaction {
pub fn get_sender_address(&self) -> ContractAddress {
match self {
InvokeTransaction::V3(tx) => tx.sender_address,
}
}
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize, PartialEq, Eq))]
#[serde(untagged)]
pub enum DeployAccountTransaction {
V3(Box<DeployAccountTransactionV3>),
}
impl DeployAccountTransaction {
pub fn get_contract_address(&self) -> &ContractAddress {
match self {
DeployAccountTransaction::V3(tx) => tx.get_contract_address(),
}
}
}
pub fn deserialize_paid_fee_on_l1<'de, D>(deserializer: D) -> Result<u128, D::Error>
where
D: Deserializer<'de>,
{
let buf = String::deserialize(deserializer)?;
let err_msg = format!("paid_fee_on_l1: expected 0x-prefixed hex string, got: {buf}");
if !buf.starts_with("0x") {
return Err(serde::de::Error::custom(err_msg));
}
u128::from_str_radix(&buf[2..], 16).map_err(|_| serde::de::Error::custom(err_msg))
}
fn serialize_paid_fee_on_l1<S>(paid_fee_on_l1: &u128, s: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
s.serialize_str(&format!("{paid_fee_on_l1:#x}"))
}
#[derive(Debug, Clone, Deserialize)]
pub struct EventFilter {
pub from_block: Option<BlockId>,
pub to_block: Option<BlockId>,
pub address: Option<ContractAddress>,
pub keys: Option<Vec<Vec<Felt>>>,
pub continuation_token: Option<String>,
pub chunk_size: u64,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize))]
pub struct EventsChunk {
pub events: Vec<crate::emitted_event::EmittedEvent>,
#[serde(skip_serializing_if = "Option::is_none")]
pub continuation_token: Option<String>,
}
impl From<EventsPage> for EventsChunk {
fn from(events_page: EventsPage) -> Self {
Self {
events: events_page.events.into_iter().map(|e| e.into()).collect(),
continuation_token: events_page.continuation_token,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "testing", derive(PartialEq, Eq), serde(deny_unknown_fields))]
pub struct FunctionCall {
pub contract_address: ContractAddress,
pub entry_point_selector: EntryPointSelector,
pub calldata: Calldata,
}
fn is_only_query_common(version: &Felt) -> bool {
version >= &QUERY_VERSION_OFFSET
}
fn felt_to_sn_api_chain_id(f: &Felt) -> DevnetResult<starknet_api::core::ChainId> {
Ok(starknet_api::core::ChainId::Other(
parse_cairo_short_string(f).map_err(|e| ConversionError::OutOfRangeError(e.to_string()))?,
))
}
/// Common fields for all transaction type of version 3
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BroadcastedTransactionCommonV3 {
pub version: TransactionVersion,
pub signature: TransactionSignature,
pub nonce: Nonce,
pub resource_bounds: ResourceBoundsWrapper,
pub tip: Tip,
pub paymaster_data: Vec<Felt>,
pub nonce_data_availability_mode: DataAvailabilityMode,
pub fee_data_availability_mode: DataAvailabilityMode,
}
#[derive(Debug, Clone)]
#[cfg_attr(feature = "testing", derive(PartialEq, Eq))]
pub struct ResourceBoundsWrapper {
inner: ResourceBoundsMapping,
}
impl From<&ResourceBoundsWrapper> for GasVectorComputationMode {
fn from(val: &ResourceBoundsWrapper) -> GasVectorComputationMode {
let resource_bounds = starknet_api::transaction::fields::ValidResourceBounds::from(val);
match resource_bounds {
ValidResourceBounds::L1Gas(_) => GasVectorComputationMode::NoL2Gas,
ValidResourceBounds::AllResources(_) => GasVectorComputationMode::All,
}
}
}
impl_wrapper_serialize!(ResourceBoundsWrapper);
impl_wrapper_deserialize!(ResourceBoundsWrapper, ResourceBoundsMapping);
impl ResourceBoundsWrapper {
pub fn new(
l1_gas_max_amount: u64,
l1_gas_max_price_per_unit: u128,
l1_data_gas_max_amount: u64,
l1_data_gas_max_price_per_unit: u128,
l2_gas_max_amount: u64,
l2_gas_max_price_per_unit: u128,
) -> Self {
ResourceBoundsWrapper {
inner: ResourceBoundsMapping {
l1_gas: ResourceBounds {
max_amount: l1_gas_max_amount,
max_price_per_unit: l1_gas_max_price_per_unit,
},
l1_data_gas: ResourceBounds {
max_amount: l1_data_gas_max_amount,
max_price_per_unit: l1_data_gas_max_price_per_unit,
},
l2_gas: ResourceBounds {
max_amount: l2_gas_max_amount,
max_price_per_unit: l2_gas_max_price_per_unit,
},
},
}
}
}
fn convert_resource_bounds_from_starknet_rs_to_starknet_api(
bounds: ResourceBounds,
) -> starknet_api::transaction::fields::ResourceBounds {
starknet_api::transaction::fields::ResourceBounds {
max_amount: starknet_api::execution_resources::GasAmount(bounds.max_amount),
max_price_per_unit: GasPrice(bounds.max_price_per_unit),
}
}
impl From<&ResourceBoundsWrapper> for starknet_api::transaction::fields::ValidResourceBounds {
fn from(value: &ResourceBoundsWrapper) -> Self {
let l1_gas_max_amount = value.inner.l1_gas.max_amount;
let l2_gas_max_amount = value.inner.l2_gas.max_amount;
let l1_data_gas_max_amount = value.inner.l1_data_gas.max_amount;
match (l1_gas_max_amount, l2_gas_max_amount, l1_data_gas_max_amount) {
// providing max amount 0 for each resource bound is possible in the case of
// estimate fee
(0, 0, 0) => ValidResourceBounds::AllResources(AllResourceBounds::default()),
(_, 0, 0) => starknet_api::transaction::fields::ValidResourceBounds::L1Gas(
convert_resource_bounds_from_starknet_rs_to_starknet_api(
value.inner.l1_gas.clone(),
),
),
_ => starknet_api::transaction::fields::ValidResourceBounds::AllResources(
AllResourceBounds {
l1_gas: convert_resource_bounds_from_starknet_rs_to_starknet_api(
value.inner.l1_gas.clone(),
),
l2_gas: convert_resource_bounds_from_starknet_rs_to_starknet_api(
value.inner.l2_gas.clone(),
),
l1_data_gas: convert_resource_bounds_from_starknet_rs_to_starknet_api(
value.inner.l1_data_gas.clone(),
),
},
),
}
}
}
impl BroadcastedTransactionCommonV3 {
/// Checks if total accumulated fee of resource_bounds for l1 is equal to 0 or for l2 is not
/// zero
pub fn are_gas_bounds_valid(&self) -> bool {
let ResourceBoundsMapping { l1_gas, l2_gas, l1_data_gas } = &self.resource_bounds.inner;
let is_gt_zero = |gas: &ResourceBounds| gas.max_amount > 0 && gas.max_price_per_unit > 0;
// valid set of resources are:
// 1. l1_gas > 0, l2_gas = 0, l1_data_gas = 0
// 2. l2_gas > 0, l1_data_gas > 0
match (l1_gas, l2_gas, l1_data_gas) {
// l1 > 0 and l2 = 0 and l1_data = 0 => valid
(l1, l2, l1_data) if is_gt_zero(l1) && !is_gt_zero(l2) && !is_gt_zero(l1_data) => {
tracing::warn!(
"From version 0.5.0 V3 transactions that specify only L1 gas bounds are \
invalid. Please upgrade your client to provide values for the triplet \
(L1_GAS, L1_DATA_GAS, L2_GAS)."
);
true
}
// l2 > 0 and l1_data > 0
// l1 gas is not checked, because l1 gas is used for L2->L1 messages and not every
// transaction sends data to L1
(_, l2, l1_data) if is_gt_zero(l2) && is_gt_zero(l1_data) => true,
_ => false,
}
}
pub fn is_only_query(&self) -> bool {
is_only_query_common(&self.version)
}
pub fn get_gas_vector_computation_mode(&self) -> GasVectorComputationMode {
(&self.resource_bounds).into()
}
}
#[derive(Debug, Clone, Deserialize)]
#[serde(tag = "type", rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BroadcastedTransaction {
Invoke(BroadcastedInvokeTransaction),
Declare(BroadcastedDeclareTransaction),
DeployAccount(BroadcastedDeployAccountTransaction),
}
impl BroadcastedTransaction {
pub fn to_blockifier_account_transaction(
&self,
chain_id: &Felt,
execution_flags: ExecutionFlags,
) -> DevnetResult<blockifier::transaction::account_transaction::AccountTransaction> {
let sn_api_tx = self.to_sn_api_account_transaction(chain_id)?;
Ok(blockifier::transaction::account_transaction::AccountTransaction {
tx: sn_api_tx,
execution_flags,
})
}
pub fn to_sn_api_account_transaction(
&self,
chain_id: &Felt,
) -> DevnetResult<starknet_api::executable_transaction::AccountTransaction> {
let sn_api_tx = match self {
BroadcastedTransaction::Invoke(invoke_txn) => {
starknet_api::executable_transaction::AccountTransaction::Invoke(
invoke_txn.create_sn_api_invoke(chain_id)?,
)
}
BroadcastedTransaction::Declare(declare_txn) => {
starknet_api::executable_transaction::AccountTransaction::Declare(
declare_txn.create_sn_api_declare(chain_id)?,
)
}
BroadcastedTransaction::DeployAccount(deploy_account_txn) => {
starknet_api::executable_transaction::AccountTransaction::DeployAccount(
deploy_account_txn.create_sn_api_deploy_account(chain_id)?,
)
}
};
Ok(sn_api_tx)
}
pub fn get_type(&self) -> TransactionType {
match self {
BroadcastedTransaction::Invoke(_) => TransactionType::Invoke,
BroadcastedTransaction::Declare(_) => TransactionType::Declare,
BroadcastedTransaction::DeployAccount(_) => TransactionType::DeployAccount,
}
}
pub fn are_gas_bounds_valid(&self) -> bool {
match self {
BroadcastedTransaction::Invoke(broadcasted_invoke_transaction) => {
broadcasted_invoke_transaction.are_gas_bounds_valid()
}
BroadcastedTransaction::Declare(broadcasted_declare_transaction) => {
broadcasted_declare_transaction.are_gas_bounds_valid()
}
BroadcastedTransaction::DeployAccount(broadcasted_deploy_account_transaction) => {
broadcasted_deploy_account_transaction.are_gas_bounds_valid()
}
}
}
pub fn gas_vector_computation_mode(&self) -> GasVectorComputationMode {
match self {
BroadcastedTransaction::Declare(BroadcastedDeclareTransaction::V3(declare_v3)) => {
declare_v3.common.get_gas_vector_computation_mode()
}
BroadcastedTransaction::DeployAccount(BroadcastedDeployAccountTransaction::V3(
deploy_account_v3,
)) => deploy_account_v3.common.get_gas_vector_computation_mode(),
BroadcastedTransaction::Invoke(BroadcastedInvokeTransaction::V3(invoke_v3)) => {
invoke_v3.common.get_gas_vector_computation_mode()
}
}
}
pub fn requires_strict_nonce_check(&self, using_pre_confirmed_block: bool) -> bool {
match self {
BroadcastedTransaction::Invoke(tx) => {
tx.requires_strict_nonce_check(using_pre_confirmed_block)
}
BroadcastedTransaction::Declare(_) => true,
BroadcastedTransaction::DeployAccount(tx) => {
tx.requires_strict_nonce_check(using_pre_confirmed_block)
}
}
}
}
#[derive(Debug, Clone)]
pub enum BroadcastedDeclareTransaction {
V3(Box<BroadcastedDeclareTransactionV3>),
}
impl BroadcastedDeclareTransaction {
pub fn are_gas_bounds_valid(&self) -> bool {
match self {
BroadcastedDeclareTransaction::V3(v3) => v3.common.are_gas_bounds_valid(),
}
}
pub fn is_only_query(&self) -> bool {
match self {
BroadcastedDeclareTransaction::V3(tx) => tx.common.is_only_query(),
}
}
/// Creates a blockifier declare transaction from the current transaction.
/// The transaction hash is computed using the given chain id.
///
/// # Arguments
/// `chain_id` - the chain id to use for the transaction hash computation
pub fn create_sn_api_declare(
&self,
chain_id: &Felt,
) -> DevnetResult<starknet_api::executable_transaction::DeclareTransaction> {
let sn_api_chain_id = felt_to_sn_api_chain_id(chain_id)?;
let (sn_api_transaction, tx_hash, class_info) = match self {
BroadcastedDeclareTransaction::V3(v3) => {
let sierra_class_hash = compute_sierra_class_hash(&v3.contract_class)?;
let sn_api_declare = starknet_api::transaction::DeclareTransaction::V3(
starknet_api::transaction::DeclareTransactionV3 {
resource_bounds: (&v3.common.resource_bounds).into(),
tip: v3.common.tip,
signature: starknet_api::transaction::fields::TransactionSignature(
Arc::new(v3.common.signature.clone()),
),
nonce: starknet_api::core::Nonce(v3.common.nonce),
class_hash: starknet_api::core::ClassHash(sierra_class_hash),
compiled_class_hash: starknet_api::core::CompiledClassHash(
v3.compiled_class_hash,
),
sender_address: v3.sender_address.into(),
nonce_data_availability_mode: v3.common.nonce_data_availability_mode,
fee_data_availability_mode: v3.common.fee_data_availability_mode,
paymaster_data: starknet_api::transaction::fields::PaymasterData(
v3.common.paymaster_data.clone(),
),
account_deployment_data:
starknet_api::transaction::fields::AccountDeploymentData(
v3.account_deployment_data.clone(),
),
},
);
let class_info: ClassInfo =
ContractClass::Cairo1(v3.contract_class.clone()).try_into()?;
let tx_version: starknet_api::transaction::TransactionVersion = signed_tx_version(
&sn_api_declare.version(),
&TransactionOptions { only_query: self.is_only_query() },
);
let tx_hash =
sn_api_declare.calculate_transaction_hash(&sn_api_chain_id, &tx_version)?;
(sn_api_declare, tx_hash, class_info)
}
};
Ok(starknet_api::executable_transaction::DeclareTransaction {
tx: sn_api_transaction,
tx_hash,
class_info,
})
}
}
#[derive(Debug, Clone)]
pub enum BroadcastedDeployAccountTransaction {
V3(BroadcastedDeployAccountTransactionV3),
}
impl BroadcastedDeployAccountTransaction {
pub fn are_gas_bounds_valid(&self) -> bool {
match self {
BroadcastedDeployAccountTransaction::V3(v3) => v3.common.are_gas_bounds_valid(),
}
}
pub fn is_only_query(&self) -> bool {
match self {
BroadcastedDeployAccountTransaction::V3(tx) => tx.common.is_only_query(),
}
}
pub fn requires_strict_nonce_check(&self, using_pre_confirmed_block: bool) -> bool {
!using_pre_confirmed_block
}
/// Creates a blockifier deploy account transaction from the current transaction.
/// The transaction hash is computed using the given chain id.
///
/// # Arguments
/// `chain_id` - the chain id to use for the transaction hash computation
pub fn create_sn_api_deploy_account(
&self,
chain_id: &Felt,
) -> DevnetResult<starknet_api::executable_transaction::DeployAccountTransaction> {
let sn_api_transaction = match self {
BroadcastedDeployAccountTransaction::V3(v3) => {
let sn_api_transaction = starknet_api::transaction::DeployAccountTransactionV3 {
resource_bounds: (&v3.common.resource_bounds).into(),
tip: v3.common.tip,
signature: starknet_api::transaction::fields::TransactionSignature(Arc::new(
v3.common.signature.clone(),
)),
nonce: starknet_api::core::Nonce(v3.common.nonce),
class_hash: starknet_api::core::ClassHash(v3.class_hash),
nonce_data_availability_mode: v3.common.nonce_data_availability_mode,
fee_data_availability_mode: v3.common.fee_data_availability_mode,
paymaster_data: starknet_api::transaction::fields::PaymasterData(
v3.common.paymaster_data.clone(),
),
contract_address_salt: starknet_api::transaction::fields::ContractAddressSalt(
v3.contract_address_salt,
),
constructor_calldata: starknet_api::transaction::fields::Calldata(Arc::new(
v3.constructor_calldata.clone(),
)),
};
starknet_api::transaction::DeployAccountTransaction::V3(sn_api_transaction)
}
};
let chain_id = felt_to_sn_api_chain_id(chain_id)?;
let tx_version: starknet_api::transaction::TransactionVersion = signed_tx_version(
&sn_api_transaction.version(),
&TransactionOptions { only_query: self.is_only_query() },
);
let tx_hash = sn_api_transaction.calculate_transaction_hash(&chain_id, &tx_version)?;
// copied from starknet_api::executable_transaction::DeployAccountTransaction::create(
let contract_address = calculate_contract_address(
sn_api_transaction.contract_address_salt(),
sn_api_transaction.class_hash(),
&sn_api_transaction.constructor_calldata(),
starknet_api::core::ContractAddress::default(),
)?;
Ok(starknet_api::executable_transaction::DeployAccountTransaction {
tx: sn_api_transaction,
tx_hash,
contract_address,
})
}
}
#[derive(Debug, Clone)]
pub enum BroadcastedInvokeTransaction {
V3(BroadcastedInvokeTransactionV3),
}
impl BroadcastedInvokeTransaction {
pub fn are_gas_bounds_valid(&self) -> bool {
match self {
BroadcastedInvokeTransaction::V3(v3) => v3.common.are_gas_bounds_valid(),
}
}
pub fn is_only_query(&self) -> bool {
match self {
BroadcastedInvokeTransaction::V3(tx) => tx.common.is_only_query(),
}
}
pub fn requires_strict_nonce_check(&self, using_pre_confirmed_block: bool) -> bool {
!using_pre_confirmed_block
}
/// Creates a blockifier invoke transaction from the current transaction.
/// The transaction hash is computed using the given chain id.
///
/// # Arguments
/// `chain_id` - the chain id to use for the transaction hash computation
pub fn create_sn_api_invoke(
&self,
chain_id: &Felt,
) -> DevnetResult<starknet_api::executable_transaction::InvokeTransaction> {
let sn_api_transaction = match self {
BroadcastedInvokeTransaction::V3(v3) => v3.create_sn_api_invoke()?,
};
let chain_id = felt_to_sn_api_chain_id(chain_id)?;
let tx_version: starknet_api::transaction::TransactionVersion = signed_tx_version(
&sn_api_transaction.version(),
&TransactionOptions { only_query: self.is_only_query() },
);
let tx_hash = sn_api_transaction.calculate_transaction_hash(&chain_id, &tx_version)?;
Ok(starknet_api::executable_transaction::InvokeTransaction {
tx: sn_api_transaction,
tx_hash,
})
}
}
impl<'de> Deserialize<'de> for BroadcastedDeclareTransaction {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = serde_json::Value::deserialize(deserializer)?;
let version_raw = value.get("version").ok_or(serde::de::Error::missing_field("version"))?;
match version_raw.as_str() {
Some(v) if ["0x3", "0x100000000000000000000000000000003"].contains(&v) => {
let unpacked = serde_json::from_value(value).map_err(|e| {
serde::de::Error::custom(format!("Invalid declare transaction v3: {e}"))
})?;
Ok(BroadcastedDeclareTransaction::V3(Box::new(unpacked)))
}
_ => Err(serde::de::Error::custom(format!(
"Invalid version of declare transaction: {version_raw}"
))),
}
}
}
impl<'de> Deserialize<'de> for BroadcastedDeployAccountTransaction {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = serde_json::Value::deserialize(deserializer)?;
let version_raw = value.get("version").ok_or(serde::de::Error::missing_field("version"))?;
match version_raw.as_str() {
Some(v) if ["0x3", "0x100000000000000000000000000000003"].contains(&v) => {
let unpacked = serde_json::from_value(value).map_err(|e| {
serde::de::Error::custom(format!("Invalid deploy account transaction v3: {e}"))
})?;
Ok(BroadcastedDeployAccountTransaction::V3(unpacked))
}
_ => Err(serde::de::Error::custom(format!(
"Invalid version of deploy account transaction: {version_raw}"
))),
}
}
}
impl<'de> Deserialize<'de> for BroadcastedInvokeTransaction {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = serde_json::Value::deserialize(deserializer)?;
let version_raw = value.get("version").ok_or(serde::de::Error::missing_field("version"))?;
match version_raw.as_str() {
Some(v) if ["0x3", "0x100000000000000000000000000000003"].contains(&v) => {
let unpacked = serde_json::from_value(value).map_err(|e| {
serde::de::Error::custom(format!("Invalid invoke transaction v3: {e}"))
})?;
Ok(BroadcastedInvokeTransaction::V3(unpacked))
}
_ => Err(serde::de::Error::custom(format!(
"Invalid version of invoke transaction: {version_raw}"
))),
}
}
}
/// Flags that indicate how to simulate a given transaction.
/// By default, the sequencer behavior is replicated locally (enough funds are expected to be in the
/// account, and fee will be deducted from the balance before the simulation of the next
/// transaction). To skip the fee charge, use the SKIP_FEE_CHARGE flag.
#[derive(Debug, Clone, Eq, PartialEq, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum SimulationFlag {
SkipValidate,
SkipFeeCharge,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize))]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum CallType {
LibraryCall,
Call,
Delegate,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct FunctionInvocation {
contract_address: ContractAddress,
entry_point_selector: EntryPointSelector,
calldata: Calldata,
caller_address: ContractAddress,
class_hash: Felt,
entry_point_type: EntryPointType,
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | true |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/macro_utils.rs | crates/starknet-devnet-types/src/rpc/macro_utils.rs | #[macro_export]
macro_rules! impl_wrapper_serialize {
($wrapper_name:ident) => {
impl serde::Serialize for $wrapper_name {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
self.inner.serialize(serializer)
}
}
};
}
#[macro_export]
macro_rules! impl_wrapper_deserialize {
($wrapper_name:ident, $name:ident) => {
impl<'de> serde::Deserialize<'de> for $wrapper_name {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
Ok($wrapper_name { inner: $name::deserialize(deserializer)? })
}
}
};
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/state.rs | crates/starknet-devnet-types/src/rpc/state.rs | use num_bigint::BigUint;
use serde::Serialize;
use starknet_types_core::felt::Felt;
use super::block::BlockRoot;
use crate::contract_address::ContractAddress;
use crate::felt::{BlockHash, ClassHash, CompiledClassHash, Nonce};
use crate::patricia_key::PatriciaKey;
pub type Balance = BigUint;
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub enum StateUpdateResult {
StateUpdate(StateUpdate),
PreConfirmedStateUpdate(PreConfirmedStateUpdate),
}
impl StateUpdateResult {
pub fn get_state_diff(&self) -> &ThinStateDiff {
match self {
StateUpdateResult::StateUpdate(s) => &s.state_diff,
StateUpdateResult::PreConfirmedStateUpdate(s) => &s.state_diff,
}
}
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct StateUpdate {
pub block_hash: BlockHash,
pub new_root: BlockRoot,
pub old_root: BlockRoot,
pub state_diff: ThinStateDiff,
}
impl StateUpdate {
/// New and old root are not computed - Devnet does not store block data in a tree.
pub fn new(block_hash: Felt, state_diff: ThinStateDiff) -> Self {
Self { block_hash, new_root: Felt::default(), old_root: Felt::default(), state_diff }
}
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct PreConfirmedStateUpdate {
pub old_root: Option<BlockRoot>,
pub state_diff: ThinStateDiff,
}
#[derive(Debug, Default, Clone, Serialize)]
#[cfg_attr(
feature = "testing",
derive(serde::Deserialize, Eq, PartialEq),
serde(deny_unknown_fields)
)]
pub struct ThinStateDiff {
pub deployed_contracts: Vec<DeployedContract>,
pub storage_diffs: Vec<StorageDiff>,
pub declared_classes: Vec<ClassHashPair>,
pub deprecated_declared_classes: Vec<ClassHash>,
pub nonces: Vec<ContractNonce>,
pub replaced_classes: Vec<ReplacedClasses>,
// In Devnet, this will always be None as:
// 1) There is no migration process when starting Devnet without forking as state is empty.
// 2) When forking, there is no RPC support for fetching compiled classes from origin (yet).
// This is added for adherence to Starknet spec and/or future use.
#[serde(skip_serializing_if = "Option::is_none")]
pub migrated_compiled_classes: Option<Vec<ClassHashPair>>,
}
/// A deployed contract in Starknet.
#[derive(Debug, Default, Clone, Serialize)]
#[cfg_attr(
feature = "testing",
derive(serde::Deserialize, Eq, PartialEq),
serde(deny_unknown_fields)
)]
pub struct DeployedContract {
pub address: ContractAddress,
pub class_hash: ClassHash,
}
/// Storage differences in Starknet.
// Invariant: Storage keys are strictly increasing. In particular, no key appears twice.
#[derive(Debug, Default, Clone, Serialize)]
#[cfg_attr(
feature = "testing",
derive(serde::Deserialize, Eq, PartialEq),
serde(deny_unknown_fields)
)]
pub struct StorageDiff {
pub address: ContractAddress,
pub storage_entries: Vec<StorageEntry>,
}
/// A storage entry in a contract.
#[derive(Debug, Default, Clone, Serialize)]
#[cfg_attr(
feature = "testing",
derive(serde::Deserialize, Eq, PartialEq),
serde(deny_unknown_fields)
)]
pub struct StorageEntry {
pub key: PatriciaKey,
pub value: Felt,
}
#[derive(Debug, Clone, Default, Serialize)]
#[cfg_attr(feature = "testing", derive(PartialEq, Eq, serde::Deserialize))]
pub struct ClassHashPair {
pub class_hash: ClassHash,
pub compiled_class_hash: CompiledClassHash,
}
#[derive(Debug, Clone, Default, Serialize)]
#[cfg_attr(feature = "testing", derive(Eq, PartialEq, serde::Deserialize))]
pub struct ReplacedClasses {
pub contract_address: ContractAddress,
pub class_hash: ClassHash,
}
/// The nonce of a Starknet contract.
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(
feature = "testing",
derive(serde::Deserialize, Eq, PartialEq),
serde(deny_unknown_fields)
)]
pub struct ContractNonce {
pub contract_address: ContractAddress,
pub nonce: Nonce,
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/messaging.rs | crates/starknet-devnet-types/src/rpc/messaging.rs | use serde::{Deserialize, Serialize};
use starknet_rs_core::types::{EthAddress, Felt, Hash256, MsgToL1, MsgToL2};
use crate::contract_address::ContractAddress;
use crate::error::{DevnetResult, Error};
use crate::felt::{Calldata, EntryPointSelector, Nonce, try_felt_to_num};
use crate::rpc::eth_address::EthAddressWrapper;
/// An L1 to L2 message.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
#[cfg_attr(feature = "testing", derive(PartialEq, Eq))]
pub struct MessageToL2 {
pub l1_transaction_hash: Option<Hash256>,
pub l2_contract_address: ContractAddress,
pub entry_point_selector: EntryPointSelector,
pub l1_contract_address: ContractAddress,
pub payload: Calldata,
pub paid_fee_on_l1: Felt,
pub nonce: Nonce,
}
impl MessageToL2 {
pub fn hash(&self) -> DevnetResult<Hash256> {
let msg_to_l2 = MsgToL2 {
from_address: EthAddress::from_felt(&self.l1_contract_address.into()).map_err(
|err| {
Error::ConversionError(crate::error::ConversionError::OutOfRangeError(
err.to_string(),
))
},
)?,
to_address: self.l2_contract_address.into(),
selector: self.entry_point_selector,
payload: self.payload.clone(),
nonce: try_felt_to_num::<u64>(self.nonce).map_err(|err| {
Error::ConversionError(crate::error::ConversionError::OutOfRangeError(
err.to_string(),
))
})?,
};
Ok(msg_to_l2.hash())
}
}
pub type L2ToL1Payload = Vec<Felt>;
/// An L2 to L1 message.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct MessageToL1 {
pub from_address: ContractAddress,
pub to_address: EthAddressWrapper,
pub payload: L2ToL1Payload,
}
impl MessageToL1 {
/// Computes the hash of a `MessageToL1`.
/// Re-uses the already tested hash computation
/// from starknet-rs.
pub fn hash(&self) -> Hash256 {
let msg_to_l1 = MsgToL1 {
from_address: self.from_address.into(),
to_address: self.to_address.inner.clone().into(),
payload: self.payload.clone(),
};
msg_to_l1.hash()
}
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct OrderedMessageToL1 {
pub order: usize,
#[serde(flatten)]
pub message: MessageToL1,
}
impl OrderedMessageToL1 {
pub fn new(
msg: &blockifier::execution::call_info::OrderedL2ToL1Message,
from_address: ContractAddress,
) -> DevnetResult<Self> {
Ok(Self {
order: msg.order,
message: MessageToL1 {
from_address,
to_address: msg.message.to_address.try_into()?,
payload: msg.message.payload.0.clone(),
},
})
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/block.rs | crates/starknet-devnet-types/src/rpc/block.rs | use serde::{Deserialize, Deserializer, Serialize};
use starknet_api::block::{BlockNumber, BlockTimestamp};
use starknet_api::core::{
EventCommitment, ReceiptCommitment, StateDiffCommitment, TransactionCommitment,
};
use starknet_api::data_availability::L1DataAvailabilityMode;
use starknet_rs_core::types::Felt;
use crate::contract_address::ContractAddress;
use crate::felt::BlockHash;
use crate::rpc::transactions::Transactions;
pub type BlockRoot = Felt;
#[derive(Clone, Debug, Copy, PartialEq, Eq)]
pub enum BlockId {
/// Block hash.
Hash(Felt),
/// Block number (height).
Number(u64),
/// Block tag
Tag(BlockTag),
}
impl From<BlockId> for starknet_rs_core::types::BlockId {
fn from(block_id: BlockId) -> Self {
match block_id {
BlockId::Hash(felt) => Self::Hash(felt),
BlockId::Number(n) => Self::Number(n),
BlockId::Tag(tag) => Self::Tag(tag.into()),
}
}
}
impl<'de> Deserialize<'de> for BlockId {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Copy, Clone, Debug, Deserialize)]
enum BlockHashOrNumber {
#[serde(rename = "block_hash")]
Hash(Felt),
#[serde(rename = "block_number")]
Number(u64),
}
let value = serde_json::Value::deserialize(deserializer)?;
match value.as_str() {
Some("latest") => Ok(Self::Tag(BlockTag::Latest)),
Some("pre_confirmed") => Ok(Self::Tag(BlockTag::PreConfirmed)),
Some("l1_accepted") => Ok(Self::Tag(BlockTag::L1Accepted)),
_ => match serde_json::from_value::<BlockHashOrNumber>(value) {
Ok(BlockHashOrNumber::Hash(hash)) => Ok(Self::Hash(hash)),
Ok(BlockHashOrNumber::Number(n)) => Ok(Self::Number(n)),
Err(_) => Err(serde::de::Error::custom(
"Invalid block ID. Expected object with key (block_hash or block_number) or \
tag ('pre_confirmed' or 'latest' or 'l1_accepted').",
)),
},
}
}
}
#[derive(Debug, Clone)]
#[allow(clippy::large_enum_variant)] // Block is most dominant variant, doesn't matter if it is larger
pub enum BlockResult {
Block(Block),
PreConfirmedBlock(PreConfirmedBlock),
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Deserialize, Serialize, PartialOrd, Ord)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BlockStatus {
/// Almost like pre-confirmed.
PreConfirmed,
/// A block that was created on L2.
AcceptedOnL2,
/// A block that was accepted on L1.
AcceptedOnL1,
/// A block rejected on L1.
Rejected,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize), serde(deny_unknown_fields))]
pub struct Block {
pub status: BlockStatus,
#[serde(flatten)]
pub header: BlockHeader,
pub transactions: Transactions,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize), serde(deny_unknown_fields))]
pub struct PreConfirmedBlock {
#[serde(flatten)]
pub header: PreConfirmedBlockHeader,
pub transactions: Transactions,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize), serde(deny_unknown_fields))]
pub struct BlockHeader {
pub block_hash: BlockHash,
pub parent_hash: BlockHash,
pub block_number: BlockNumber,
pub sequencer_address: ContractAddress,
pub new_root: BlockRoot,
pub timestamp: BlockTimestamp,
pub starknet_version: String,
pub l1_gas_price: ResourcePrice,
pub l2_gas_price: ResourcePrice,
pub l1_data_gas_price: ResourcePrice,
pub l1_da_mode: L1DataAvailabilityMode,
pub state_diff_commitment: StateDiffCommitment,
pub state_diff_length: u64,
pub transaction_commitment: TransactionCommitment,
pub event_commitment: EventCommitment,
#[serde(rename = "transaction_count")]
pub n_transactions: u64,
#[serde(rename = "event_count")]
pub n_events: u64,
pub receipt_commitment: ReceiptCommitment,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize), serde(deny_unknown_fields))]
pub struct PreConfirmedBlockHeader {
pub block_number: BlockNumber,
pub sequencer_address: ContractAddress,
pub timestamp: BlockTimestamp,
pub starknet_version: String,
pub l1_gas_price: ResourcePrice,
pub l2_gas_price: ResourcePrice,
pub l1_data_gas_price: ResourcePrice,
pub l1_da_mode: L1DataAvailabilityMode,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize), serde(deny_unknown_fields))]
pub struct ResourcePrice {
// for now this will be always 0, this field is introduced in 0.5.0
// but current version of blockifier/starknet_api doesn't return this value
pub price_in_fri: Felt,
pub price_in_wei: Felt,
}
impl From<starknet_rs_core::types::ResourcePrice> for ResourcePrice {
fn from(value: starknet_rs_core::types::ResourcePrice) -> Self {
Self { price_in_fri: value.price_in_fri, price_in_wei: value.price_in_wei }
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
/// Data about reorganized blocks, starting and ending block number and hash
pub struct ReorgData {
/// Hash of the first known block of the orphaned chain
pub starting_block_hash: BlockHash,
/// Number of the first known block of the orphaned chain
pub starting_block_number: BlockNumber,
/// The last known block of the orphaned chain
pub ending_block_hash: BlockHash,
/// Number of the last known block of the orphaned chain
pub ending_block_number: BlockNumber,
}
#[derive(Debug, Clone)]
pub enum SubscriptionBlockId {
Hash(Felt),
Number(u64),
Latest,
L1Accepted,
}
impl<'de> Deserialize<'de> for SubscriptionBlockId {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let block_id = BlockId::deserialize(deserializer)?;
match block_id {
BlockId::Hash(felt) => Ok(Self::Hash(felt)),
BlockId::Number(n) => Ok(Self::Number(n)),
BlockId::Tag(BlockTag::Latest) => Ok(Self::Latest),
BlockId::Tag(BlockTag::PreConfirmed) => {
Err(serde::de::Error::custom("Subscription block cannot be 'pre_confirmed'"))
}
BlockId::Tag(BlockTag::L1Accepted) => {
Err(serde::de::Error::custom("Subscription block cannot be 'l1_accepted'"))
}
}
}
}
impl From<SubscriptionBlockId> for BlockId {
fn from(block_id: SubscriptionBlockId) -> Self {
(&block_id).into()
}
}
impl From<&SubscriptionBlockId> for BlockId {
fn from(value: &SubscriptionBlockId) -> Self {
match value {
SubscriptionBlockId::Hash(hash) => Self::Hash(*hash),
SubscriptionBlockId::Number(n) => Self::Number(*n),
SubscriptionBlockId::Latest => Self::Tag(BlockTag::Latest),
SubscriptionBlockId::L1Accepted => Self::Tag(BlockTag::L1Accepted),
}
}
}
#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum BlockTag {
PreConfirmed,
Latest,
L1Accepted,
}
impl From<BlockTag> for starknet_rs_core::types::BlockTag {
fn from(tag: BlockTag) -> Self {
match tag {
BlockTag::PreConfirmed => Self::PreConfirmed,
BlockTag::Latest => Self::Latest,
BlockTag::L1Accepted => Self::L1Accepted,
}
}
}
#[cfg(test)]
mod test_block_id {
use serde_json::json;
use starknet_rs_core::types::Felt;
use super::BlockTag;
use crate::rpc::block::BlockId;
#[test]
fn custom_block_id_deserialization() {
for (raw, expected) in [
(r#"{"block_hash": "0x1"}"#, BlockId::Hash(Felt::ONE)),
(r#"{"block_number": 123}"#, BlockId::Number(123)),
(r#""latest""#, BlockId::Tag(BlockTag::Latest)),
(r#""pre_confirmed""#, BlockId::Tag(BlockTag::PreConfirmed)),
(r#""l1_accepted""#, BlockId::Tag(BlockTag::L1Accepted)),
] {
assert_eq!(serde_json::from_str::<BlockId>(raw).unwrap(), expected);
}
}
#[test]
fn custom_block_tag_deserialization() {
for (raw, expected) in [
("latest", BlockTag::Latest),
("pre_confirmed", BlockTag::PreConfirmed),
("l1_accepted", BlockTag::L1Accepted),
] {
assert_eq!(serde_json::from_value::<BlockTag>(json!(raw)).unwrap(), expected);
}
}
}
#[cfg(test)]
mod test_subscription_block_id {
use serde_json::json;
use super::SubscriptionBlockId;
#[test]
fn accept_latest() {
serde_json::from_value::<SubscriptionBlockId>(json!("latest")).unwrap();
}
#[test]
fn reject_non_latest_subscription_block_tag() {
for tag in ["pending", "pre_confirmed", "l1_accepted"] {
serde_json::from_value::<SubscriptionBlockId>(json!(tag)).unwrap_err();
}
}
#[test]
fn reject_random_string() {
serde_json::from_value::<SubscriptionBlockId>(json!("random string")).unwrap_err();
}
#[test]
fn accept_valid_felt_as_block_hash() {
serde_json::from_value::<SubscriptionBlockId>(json!({ "block_hash": "0x1" })).unwrap();
}
#[test]
fn reject_invalid_felt_as_block_hash() {
serde_json::from_value::<SubscriptionBlockId>(json!({ "block_hash": "invalid" }))
.unwrap_err();
}
#[test]
fn reject_unwrapped_felt_as_block_hash() {
serde_json::from_value::<SubscriptionBlockId>(json!("0x123")).unwrap_err();
}
#[test]
fn accept_valid_number_as_block_number() {
serde_json::from_value::<SubscriptionBlockId>(json!({ "block_number": 123 })).unwrap();
}
#[test]
fn reject_unwrapped_number_as_block_number() {
serde_json::from_value::<SubscriptionBlockId>(json!(123)).unwrap_err();
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/transaction_receipt.rs | crates/starknet-devnet-types/src/rpc/transaction_receipt.rs | use serde::{Deserialize, Serialize};
use starknet_api::block::BlockNumber;
use starknet_api::transaction::fields::Fee;
use starknet_rs_core::types::{ExecutionResult, Hash256};
use super::felt::BlockHash;
use super::transactions::TransactionFinalityStatus;
use crate::contract_address::ContractAddress;
use crate::emitted_event::Event;
use crate::felt::TransactionHash;
use crate::rpc::messaging::MessageToL1;
use crate::rpc::transactions::TransactionType;
#[derive(Debug, Clone, Serialize)]
#[serde(untagged)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize))]
pub enum TransactionReceipt {
DeployAccount(DeployAccountTransactionReceipt),
Deploy(DeployTransactionReceipt),
L1Handler(L1HandlerTransactionReceipt),
Common(CommonTransactionReceipt),
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize))]
pub struct DeployAccountTransactionReceipt {
#[serde(flatten)]
pub common: CommonTransactionReceipt,
pub contract_address: ContractAddress,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize))]
pub struct DeployTransactionReceipt {
#[serde(flatten)]
pub common: CommonTransactionReceipt,
pub contract_address: ContractAddress,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize))]
pub struct L1HandlerTransactionReceipt {
#[serde(flatten)]
pub common: CommonTransactionReceipt,
pub message_hash: Hash256,
}
impl TransactionReceipt {
pub fn finality_status(&self) -> &TransactionFinalityStatus {
let common = match self {
TransactionReceipt::DeployAccount(receipt) => &receipt.common,
TransactionReceipt::Deploy(receipt) => &receipt.common,
TransactionReceipt::L1Handler(receipt) => &receipt.common,
TransactionReceipt::Common(common) => common,
};
&common.finality_status
}
pub fn clear_block_properties(&mut self) {
let common = match self {
TransactionReceipt::DeployAccount(receipt) => &mut receipt.common,
TransactionReceipt::Deploy(receipt) => &mut receipt.common,
TransactionReceipt::L1Handler(receipt) => &mut receipt.common,
TransactionReceipt::Common(common) => common,
};
common.block_hash = None;
common.block_number = None;
}
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct CommonTransactionReceipt {
pub r#type: TransactionType,
pub transaction_hash: TransactionHash,
pub actual_fee: FeeInUnits,
pub messages_sent: Vec<MessageToL1>,
pub events: Vec<Event>,
#[serde(flatten)]
pub execution_status: ExecutionResult,
pub finality_status: TransactionFinalityStatus,
#[serde(skip_serializing_if = "Option::is_none")]
pub block_hash: Option<BlockHash>,
#[serde(skip_serializing_if = "Option::is_none")]
pub block_number: Option<BlockNumber>,
pub execution_resources: ExecutionResources,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct ExecutionResources {
pub l1_gas: u64,
pub l1_data_gas: u64,
pub l2_gas: u64,
}
impl From<&blockifier::transaction::objects::TransactionExecutionInfo> for ExecutionResources {
fn from(value: &blockifier::transaction::objects::TransactionExecutionInfo) -> Self {
ExecutionResources {
l1_gas: value.receipt.gas.l1_gas.0,
l1_data_gas: value.receipt.da_gas.l1_data_gas.0,
l2_gas: value.receipt.gas.l2_gas.0,
}
}
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize), serde(deny_unknown_fields))]
pub struct FeeAmount {
pub amount: Fee,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(feature = "testing", derive(Deserialize))]
#[serde(tag = "unit")]
pub enum FeeInUnits {
WEI(FeeAmount),
FRI(FeeAmount),
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum FeeUnit {
WEI,
FRI,
}
impl std::fmt::Display for FeeUnit {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
FeeUnit::WEI => "WEI",
FeeUnit::FRI => "FRI",
})
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/estimate_message_fee.rs | crates/starknet-devnet-types/src/rpc/estimate_message_fee.rs | use std::sync::Arc;
use serde::{Deserialize, Serialize};
use starknet_api::core::EntryPointSelector;
use starknet_api::executable_transaction::L1HandlerTransaction;
use starknet_api::transaction::fields::Calldata;
use starknet_rs_core::types::{Felt, MsgFromL1 as SrMsgFromL1, MsgFromL1, PriceUnit};
use super::block::BlockId;
use crate::error::DevnetResult;
use crate::rpc::eth_address::EthAddressWrapper;
#[derive(Clone, Debug, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct FeeEstimateWrapper {
pub l1_gas_consumed: Felt,
pub l1_data_gas_consumed: Felt,
pub l1_gas_price: Felt,
pub l1_data_gas_price: Felt,
pub l2_gas_consumed: Felt,
pub l2_gas_price: Felt,
pub overall_fee: Felt,
pub unit: PriceUnit,
}
/// Request for method starknet_estimateMessageFee
#[derive(Debug, Clone, Deserialize)]
pub struct EstimateMessageFeeRequest {
/// the message's parameters
pub message: MsgFromL1,
/// The hash of the requested block, or number (height) of the requested block, or a block tag,
/// for the block referencing the state or call the transaction on.
pub block_id: BlockId,
}
impl EstimateMessageFeeRequest {
pub fn new(block_id: BlockId, msg_from_l1: MsgFromL1) -> Self {
Self { message: msg_from_l1, block_id }
}
// TODO: add ref wrapper
pub fn get_from_address(&self) -> EthAddressWrapper {
EthAddressWrapper { inner: self.message.from_address.clone() }
}
pub fn get_to_address(&self) -> Felt {
self.message.to_address
}
pub fn get_entry_point_selector(&self) -> Felt {
self.message.entry_point_selector
}
pub fn get_payload(&self) -> &[Felt] {
&self.message.payload
}
pub fn get_block_id(&self) -> &BlockId {
&self.block_id
}
pub fn get_raw_message(&self) -> &SrMsgFromL1 {
&self.message
}
pub fn create_blockifier_l1_transaction(&self) -> DevnetResult<L1HandlerTransaction> {
let calldata = [&[self.get_from_address().into()], self.get_payload()].concat();
let l1_transaction = L1HandlerTransaction {
tx: starknet_api::transaction::L1HandlerTransaction {
contract_address: starknet_api::core::ContractAddress::try_from(
self.get_to_address(),
)?,
entry_point_selector: EntryPointSelector(self.get_entry_point_selector()),
calldata: Calldata(Arc::new(calldata)),
..Default::default()
},
paid_fee_on_l1: starknet_api::transaction::fields::Fee(1),
tx_hash: Default::default(),
};
Ok(l1_transaction)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/felt.rs | crates/starknet-devnet-types/src/rpc/felt.rs | use num_bigint::BigUint;
use starknet_types_core::felt::Felt;
use crate::error::{ConversionError, DevnetResult, Error};
/// Returns (high, low)
pub fn split_biguint(biguint: BigUint) -> (Felt, Felt) {
let high = Felt::from(&biguint >> 128);
let low_mask = (BigUint::from(1_u8) << 128) - 1_u8;
let low = Felt::from(biguint & low_mask);
(high, low)
}
/// Join high and low part of a felt as biguint
pub fn join_felts(high: &Felt, low: &Felt) -> BigUint {
let high = high.to_biguint();
let low = low.to_biguint();
(high << 128) + low
}
pub fn felt_from_prefixed_hex(s: &str) -> DevnetResult<Felt> {
if !s.starts_with("0x") {
Err(Error::ConversionError(ConversionError::CustomFromHexError(format!(
"Missing prefix 0x in {s}"
))))
} else {
Felt::from_hex(s)
.map_err(|e| Error::ConversionError(ConversionError::CustomFromHexError(e.to_string())))
}
}
pub fn try_felt_to_num<T: TryFrom<BigUint>>(f: Felt) -> Result<T, <T as TryFrom<BigUint>>::Error> {
f.to_biguint().try_into()
}
pub type Nonce = Felt;
pub type TransactionVersion = Felt;
pub type TransactionSignature = Vec<Felt>;
pub type CompiledClassHash = Felt;
pub type EntryPointSelector = Felt;
pub type Calldata = Vec<Felt>;
pub type ContractAddressSalt = Felt;
pub type BlockHash = Felt;
pub type TransactionHash = Felt;
pub type ClassHash = Felt;
pub type Key = Felt;
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/gas_modification.rs | crates/starknet-devnet-types/src/rpc/gas_modification.rs | use std::num::NonZeroU128;
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct GasModificationRequest {
pub gas_price_wei: Option<NonZeroU128>,
pub data_gas_price_wei: Option<NonZeroU128>,
pub gas_price_fri: Option<NonZeroU128>,
pub data_gas_price_fri: Option<NonZeroU128>,
pub l2_gas_price_wei: Option<NonZeroU128>,
pub l2_gas_price_fri: Option<NonZeroU128>,
pub generate_block: Option<bool>,
}
#[derive(Clone, Debug, Serialize)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct GasModification {
pub gas_price_wei: NonZeroU128,
pub data_gas_price_wei: NonZeroU128,
pub gas_price_fri: NonZeroU128,
pub data_gas_price_fri: NonZeroU128,
pub l2_gas_price_wei: NonZeroU128,
pub l2_gas_price_fri: NonZeroU128,
}
impl GasModification {
pub fn update(&mut self, request: GasModificationRequest) {
if let Some(gas_price_wei) = request.gas_price_wei {
self.gas_price_wei = gas_price_wei;
}
if let Some(data_gas_price_wei) = request.data_gas_price_wei {
self.data_gas_price_wei = data_gas_price_wei;
}
if let Some(gas_price_fri) = request.gas_price_fri {
self.gas_price_fri = gas_price_fri;
}
if let Some(data_gas_price_fri) = request.data_gas_price_fri {
self.data_gas_price_fri = data_gas_price_fri;
}
if let Some(l2_gas_price_wei) = request.l2_gas_price_wei {
self.l2_gas_price_wei = l2_gas_price_wei;
}
if let Some(l2_gas_price_fri) = request.l2_gas_price_fri {
self.l2_gas_price_fri = l2_gas_price_fri;
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/emitted_event.rs | crates/starknet-devnet-types/src/rpc/emitted_event.rs | use serde::Serialize;
use starknet_api::block::BlockNumber;
use starknet_types_core::felt::Felt;
use super::transactions::TransactionFinalityStatus;
use crate::contract_address::ContractAddress;
use crate::felt::{BlockHash, TransactionHash};
#[derive(Serialize, Clone, Debug)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct EmittedEvent {
pub transaction_hash: TransactionHash,
pub transaction_index: u64,
pub event_index: u64,
#[serde(skip_serializing_if = "Option::is_none")]
pub block_hash: Option<BlockHash>,
#[serde(skip_serializing_if = "Option::is_none")]
pub block_number: Option<BlockNumber>,
pub from_address: ContractAddress,
pub keys: Vec<Felt>,
pub data: Vec<Felt>,
}
impl From<starknet_rs_core::types::EmittedEvent> for EmittedEvent {
fn from(sn_rs_event: starknet_rs_core::types::EmittedEvent) -> Self {
Self {
transaction_hash: sn_rs_event.transaction_hash,
transaction_index: sn_rs_event.transaction_index,
event_index: sn_rs_event.event_index,
block_hash: sn_rs_event.block_hash,
block_number: sn_rs_event.block_number.map(BlockNumber),
#[allow(clippy::expect_used)]
from_address: ContractAddress::new(sn_rs_event.from_address)
.expect("Converting address to address should not fail"),
keys: sn_rs_event.keys,
data: sn_rs_event.data,
}
}
}
#[derive(Serialize, Clone, Debug)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct Event {
pub from_address: ContractAddress,
pub keys: Vec<Felt>,
pub data: Vec<Felt>,
}
#[derive(Serialize, Clone, Debug)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct OrderedEvent {
pub keys: Vec<Felt>,
pub data: Vec<Felt>,
pub order: usize,
}
impl From<&blockifier::execution::call_info::OrderedEvent> for OrderedEvent {
fn from(event: &blockifier::execution::call_info::OrderedEvent) -> Self {
Self {
order: event.order,
keys: event.event.keys.iter().map(|k| k.0).collect(),
data: event.event.data.0.clone(),
}
}
}
impl From<&EmittedEvent> for Event {
fn from(emitted_event: &EmittedEvent) -> Self {
Self {
from_address: emitted_event.from_address,
keys: emitted_event.keys.clone(),
data: emitted_event.data.clone(),
}
}
}
impl From<EmittedEvent> for Event {
fn from(emitted_event: EmittedEvent) -> Self {
(&emitted_event).into()
}
}
#[derive(Serialize, Clone, Debug)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct SubscriptionEmittedEvent {
#[serde(flatten)]
pub emitted_event: EmittedEvent,
pub finality_status: TransactionFinalityStatus,
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/transactions/broadcasted_deploy_account_transaction_v3.rs | crates/starknet-devnet-types/src/rpc/transactions/broadcasted_deploy_account_transaction_v3.rs | use serde::Deserialize;
use super::BroadcastedTransactionCommonV3;
use crate::felt::{Calldata, ClassHash, ContractAddressSalt};
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BroadcastedDeployAccountTransactionV3 {
#[serde(flatten)]
pub common: BroadcastedTransactionCommonV3,
pub contract_address_salt: ContractAddressSalt,
pub constructor_calldata: Calldata,
pub class_hash: ClassHash,
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/transactions/invoke_transaction_v3.rs | crates/starknet-devnet-types/src/rpc/transactions/invoke_transaction_v3.rs | use serde::Serialize;
use starknet_api::data_availability::DataAvailabilityMode;
use starknet_api::transaction::fields::Tip;
use starknet_types_core::felt::Felt;
use super::broadcasted_invoke_transaction_v3::BroadcastedInvokeTransactionV3;
use super::{BroadcastedTransactionCommonV3, ResourceBoundsWrapper};
use crate::contract_address::ContractAddress;
use crate::felt::{Calldata, Nonce, TransactionSignature, TransactionVersion};
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(
feature = "testing",
derive(serde::Deserialize, PartialEq, Eq),
serde(deny_unknown_fields)
)]
pub struct InvokeTransactionV3 {
version: TransactionVersion,
pub(crate) signature: TransactionSignature,
nonce: Nonce,
resource_bounds: ResourceBoundsWrapper,
tip: Tip,
paymaster_data: Vec<Felt>,
nonce_data_availability_mode: DataAvailabilityMode,
fee_data_availability_mode: DataAvailabilityMode,
account_deployment_data: Vec<Felt>,
pub(crate) sender_address: ContractAddress,
calldata: Calldata,
}
impl InvokeTransactionV3 {
pub fn new(broadcasted_txn: &BroadcastedInvokeTransactionV3) -> Self {
Self {
version: broadcasted_txn.common.version,
signature: broadcasted_txn.common.signature.clone(),
nonce: broadcasted_txn.common.nonce,
resource_bounds: broadcasted_txn.common.resource_bounds.clone(),
tip: broadcasted_txn.common.tip,
paymaster_data: broadcasted_txn.common.paymaster_data.clone(),
nonce_data_availability_mode: broadcasted_txn.common.nonce_data_availability_mode,
fee_data_availability_mode: broadcasted_txn.common.fee_data_availability_mode,
sender_address: broadcasted_txn.sender_address,
calldata: broadcasted_txn.calldata.clone(),
account_deployment_data: broadcasted_txn.account_deployment_data.clone(),
}
}
pub(crate) fn get_resource_bounds(&self) -> &ResourceBoundsWrapper {
&self.resource_bounds
}
}
impl From<InvokeTransactionV3> for BroadcastedInvokeTransactionV3 {
fn from(value: InvokeTransactionV3) -> Self {
Self {
common: BroadcastedTransactionCommonV3 {
version: value.version,
signature: value.signature,
nonce: value.nonce,
resource_bounds: value.resource_bounds,
tip: value.tip,
paymaster_data: value.paymaster_data,
nonce_data_availability_mode: value.nonce_data_availability_mode,
fee_data_availability_mode: value.fee_data_availability_mode,
},
sender_address: value.sender_address,
calldata: value.calldata,
account_deployment_data: value.account_deployment_data,
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/transactions/deploy_transaction.rs | crates/starknet-devnet-types/src/rpc/transactions/deploy_transaction.rs | use serde::Serialize;
use crate::felt::{Calldata, ClassHash, ContractAddressSalt, TransactionVersion};
#[derive(Debug, Clone, Default, Serialize)]
#[cfg_attr(
feature = "testing",
derive(serde::Deserialize, PartialEq, Eq),
serde(deny_unknown_fields)
)]
pub struct DeployTransaction {
pub version: TransactionVersion,
pub class_hash: ClassHash,
pub contract_address_salt: ContractAddressSalt,
pub constructor_calldata: Calldata,
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/transactions/broadcasted_declare_transaction_v3.rs | crates/starknet-devnet-types/src/rpc/transactions/broadcasted_declare_transaction_v3.rs | use cairo_lang_starknet_classes::contract_class::ContractClass as SierraContractClass;
use serde::Deserialize;
use starknet_rs_core::types::Felt;
use super::{BroadcastedDeclareTransaction, BroadcastedTransactionCommonV3};
use crate::contract_address::ContractAddress;
use crate::felt::CompiledClassHash;
use crate::serde_helpers::rpc_sierra_contract_class_to_sierra_contract_class::deserialize_to_sierra_contract_class;
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BroadcastedDeclareTransactionV3 {
#[serde(flatten)]
pub common: BroadcastedTransactionCommonV3,
#[serde(deserialize_with = "deserialize_to_sierra_contract_class")]
pub contract_class: SierraContractClass,
pub sender_address: ContractAddress,
pub compiled_class_hash: CompiledClassHash,
pub account_deployment_data: Vec<Felt>,
}
impl From<BroadcastedDeclareTransactionV3> for BroadcastedDeclareTransaction {
fn from(value: BroadcastedDeclareTransactionV3) -> Self {
Self::V3(Box::new(value))
}
}
// This file used to contain a test which asserts tx hash calculation. But this is no longer
// Devnet's responsibility, so there are no such tests.
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/transactions/deploy_account_transaction_v3.rs | crates/starknet-devnet-types/src/rpc/transactions/deploy_account_transaction_v3.rs | use serde::Serialize;
use starknet_api::data_availability::DataAvailabilityMode;
use starknet_api::transaction::fields::Tip;
use starknet_types_core::felt::Felt;
use super::broadcasted_deploy_account_transaction_v3::BroadcastedDeployAccountTransactionV3;
use super::{BroadcastedTransactionCommonV3, ResourceBoundsWrapper};
use crate::contract_address::ContractAddress;
use crate::felt::{
Calldata, ClassHash, ContractAddressSalt, Nonce, TransactionSignature, TransactionVersion,
};
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(
feature = "testing",
derive(serde::Deserialize, PartialEq, Eq),
serde(deny_unknown_fields)
)]
pub struct DeployAccountTransactionV3 {
version: TransactionVersion,
pub(crate) signature: TransactionSignature,
nonce: Nonce,
resource_bounds: ResourceBoundsWrapper,
tip: Tip,
paymaster_data: Vec<Felt>,
nonce_data_availability_mode: DataAvailabilityMode,
fee_data_availability_mode: DataAvailabilityMode,
contract_address_salt: ContractAddressSalt,
constructor_calldata: Calldata,
class_hash: ClassHash,
#[serde(skip)]
contract_address: ContractAddress,
}
impl DeployAccountTransactionV3 {
pub fn new(
broadcasted_txn: &BroadcastedDeployAccountTransactionV3,
contract_address: ContractAddress,
) -> Self {
Self {
version: broadcasted_txn.common.version,
signature: broadcasted_txn.common.signature.clone(),
nonce: broadcasted_txn.common.nonce,
resource_bounds: broadcasted_txn.common.resource_bounds.clone(),
tip: broadcasted_txn.common.tip,
paymaster_data: broadcasted_txn.common.paymaster_data.clone(),
nonce_data_availability_mode: broadcasted_txn.common.nonce_data_availability_mode,
fee_data_availability_mode: broadcasted_txn.common.fee_data_availability_mode,
contract_address_salt: broadcasted_txn.contract_address_salt,
constructor_calldata: broadcasted_txn.constructor_calldata.clone(),
class_hash: broadcasted_txn.class_hash,
contract_address,
}
}
pub fn get_contract_address(&self) -> &ContractAddress {
&self.contract_address
}
pub(crate) fn get_resource_bounds(&self) -> &ResourceBoundsWrapper {
&self.resource_bounds
}
}
impl From<DeployAccountTransactionV3> for BroadcastedDeployAccountTransactionV3 {
fn from(value: DeployAccountTransactionV3) -> Self {
Self {
common: BroadcastedTransactionCommonV3 {
version: value.version,
signature: value.signature,
nonce: value.nonce,
resource_bounds: value.resource_bounds,
tip: value.tip,
paymaster_data: value.paymaster_data,
nonce_data_availability_mode: value.nonce_data_availability_mode,
fee_data_availability_mode: value.fee_data_availability_mode,
},
contract_address_salt: value.contract_address_salt,
constructor_calldata: value.constructor_calldata,
class_hash: value.class_hash,
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/transactions/l1_handler_transaction.rs | crates/starknet-devnet-types/src/rpc/transactions/l1_handler_transaction.rs | use std::sync::Arc;
use serde::Serialize;
use starknet_api::core::{
ContractAddress as ApiContractAddress, EntryPointSelector as ApiEntryPointSelector,
Nonce as ApiNonce,
};
use starknet_api::executable_transaction::L1HandlerTransaction as ApiL1HandlerTransaction;
use starknet_api::transaction::fields::{Calldata as ApiCalldata, Fee as ApiFee};
use starknet_api::transaction::{
TransactionHash as ApiTransactionHash, TransactionVersion as ApiTransactionVersion,
};
use starknet_rs_core::crypto::compute_hash_on_elements;
use starknet_rs_core::types::{Felt, Hash256};
use super::serialize_paid_fee_on_l1;
use crate::constants::PREFIX_L1_HANDLER;
use crate::contract_address::ContractAddress;
use crate::error::{ConversionError, DevnetResult, Error};
use crate::felt::{Calldata, EntryPointSelector, Nonce, TransactionVersion, try_felt_to_num};
use crate::rpc::messaging::MessageToL2;
#[derive(Debug, Clone, Default, Serialize, Eq, PartialEq)]
#[cfg_attr(feature = "testing", derive(serde::Deserialize), serde(deny_unknown_fields))]
pub struct L1HandlerTransaction {
/// The hash of the L1 transaction that triggered this L1 handler execution.
/// Omissible if received via mock (devnet_postmanSendMessageToL2)
pub l1_transaction_hash: Option<Hash256>,
pub version: TransactionVersion,
pub nonce: Nonce,
pub contract_address: ContractAddress,
pub entry_point_selector: EntryPointSelector,
pub calldata: Calldata,
#[serde(
serialize_with = "serialize_paid_fee_on_l1",
deserialize_with = "super::deserialize_paid_fee_on_l1"
)]
pub paid_fee_on_l1: u128,
}
impl L1HandlerTransaction {
/// Computes the hash of a `L1HandlerTransaction`.
///
/// # Arguments
///
/// * `chain_id` - The chain ID.
pub fn compute_hash(&self, chain_id: Felt) -> Felt {
// No fee on L2 for L1 handler transaction.
let fee = Felt::ZERO;
compute_hash_on_elements(&[
PREFIX_L1_HANDLER,
self.version,
self.contract_address.into(),
self.entry_point_selector,
compute_hash_on_elements(&self.calldata),
fee,
chain_id,
self.nonce,
])
}
/// Creates a blockifier version of `L1HandlerTransaction`.
pub fn create_sn_api_transaction(
&self,
chain_id: Felt,
) -> DevnetResult<ApiL1HandlerTransaction> {
let transaction = ApiL1HandlerTransaction {
tx: starknet_api::transaction::L1HandlerTransaction {
contract_address: ApiContractAddress::from(self.contract_address),
entry_point_selector: ApiEntryPointSelector(self.entry_point_selector),
calldata: ApiCalldata(Arc::new(self.calldata.clone())),
nonce: ApiNonce(self.nonce),
version: ApiTransactionVersion(self.version),
},
paid_fee_on_l1: ApiFee(self.paid_fee_on_l1),
tx_hash: ApiTransactionHash(self.compute_hash(chain_id)),
};
Ok(transaction)
}
/// Converts a `MessageToL2` into a `L1HandlerTransaction`.
///
/// # Arguments
///
/// * `message` - The message to be converted.
/// * `chain_id` - The L1 node chain id.
pub fn try_from_message_to_l2(message: MessageToL2) -> DevnetResult<Self> {
let paid_fee_on_l1: u128 = try_felt_to_num(message.paid_fee_on_l1).map_err(|_| {
ConversionError::OutOfRangeError(format!(
"paid_fee_on_l1 is expected to be a u128 value, found: {:?}",
message.paid_fee_on_l1,
))
})?;
let mut calldata = vec![message.l1_contract_address.into()];
for u in message.payload {
calldata.push(u);
}
Ok(Self {
contract_address: message.l2_contract_address,
entry_point_selector: message.entry_point_selector,
calldata,
nonce: message.nonce,
paid_fee_on_l1,
l1_transaction_hash: message.l1_transaction_hash,
version: Felt::ZERO, // currently, only version 0 is supported
})
}
}
impl TryFrom<&L1HandlerTransaction> for MessageToL2 {
type Error = Error;
fn try_from(value: &L1HandlerTransaction) -> Result<Self, Self::Error> {
let l1_contract_address = value.calldata.first().ok_or(Error::ConversionError(
ConversionError::InvalidInternalStructure(
"L1HandlerTransaction calldata is expected to have at least one element"
.to_string(),
),
))?;
let payload = value.calldata[1..].to_vec();
Ok(MessageToL2 {
l1_transaction_hash: value.l1_transaction_hash,
l2_contract_address: value.contract_address,
entry_point_selector: value.entry_point_selector,
l1_contract_address: ContractAddress::new(*l1_contract_address)?,
payload,
paid_fee_on_l1: Felt::from(value.paid_fee_on_l1),
nonce: value.nonce,
})
}
}
#[cfg(test)]
mod tests {
use starknet_rs_core::types::Hash256;
use super::*;
use crate::chain_id::ChainId;
use crate::felt::felt_from_prefixed_hex;
use crate::rpc::transactions::ContractAddress;
#[test]
fn l1_handler_tx_from_message_to_l2() {
// Test based on Goerli tx hash:
// 0x6182c63599a9638272f1ce5b5cadabece9c81c2d2b8f88ab7a294472b8fce8b
let from_address = "0x000000000000000000000000be3C44c09bc1a3566F3e1CA12e5AbA0fA4Ca72Be";
let to_address = "0x039dc79e64f4bb3289240f88e0bae7d21735bef0d1a51b2bf3c4730cb16983e1";
let selector = "0x02f15cff7b0eed8b9beb162696cf4e3e0e35fa7032af69cd1b7d2ac67a13f40f";
let nonce = 783082_u128;
let fee = 30000_u128;
let payload: Vec<Felt> = vec![Felt::ONE, Felt::TWO];
let calldata: Vec<Felt> =
vec![felt_from_prefixed_hex(from_address).unwrap(), Felt::ONE, Felt::TWO];
let message = MessageToL2 {
l1_transaction_hash: None,
l1_contract_address: ContractAddress::new(
felt_from_prefixed_hex(from_address).unwrap(),
)
.unwrap(),
l2_contract_address: ContractAddress::new(felt_from_prefixed_hex(to_address).unwrap())
.unwrap(),
entry_point_selector: felt_from_prefixed_hex(selector).unwrap(),
payload,
nonce: nonce.into(),
paid_fee_on_l1: fee.into(),
};
let transaction_hash = felt_from_prefixed_hex(
"0x6182c63599a9638272f1ce5b5cadabece9c81c2d2b8f88ab7a294472b8fce8b",
)
.unwrap();
// message hash string taken from:
// https://testnet.starkscan.co/tx/0x06182c63599a9638272f1ce5b5cadabece9c81c2d2b8f88ab7a294472b8fce8b#messagelogs
assert_eq!(
Hash256::from_hex("0x9e658ca0f2727a3b43d0ed8171321f8b85685f5085ca5b16514d5bcb7c8a7590")
.unwrap(),
message.hash().unwrap()
);
let expected_tx = L1HandlerTransaction {
contract_address: ContractAddress::new(felt_from_prefixed_hex(to_address).unwrap())
.unwrap(),
entry_point_selector: felt_from_prefixed_hex(selector).unwrap(),
calldata,
nonce: nonce.into(),
paid_fee_on_l1: fee,
..Default::default()
};
let transaction = L1HandlerTransaction::try_from_message_to_l2(message).unwrap();
assert_eq!(transaction, expected_tx);
assert_eq!(transaction.compute_hash(ChainId::goerli_legacy_id()), transaction_hash);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/transactions/declare_transaction_v3.rs | crates/starknet-devnet-types/src/rpc/transactions/declare_transaction_v3.rs | use serde::Serialize;
use starknet_api::data_availability::DataAvailabilityMode;
use starknet_api::transaction::fields::Tip;
use starknet_types_core::felt::Felt;
use super::ResourceBoundsWrapper;
use super::broadcasted_declare_transaction_v3::BroadcastedDeclareTransactionV3;
use crate::contract_address::ContractAddress;
use crate::felt::{ClassHash, CompiledClassHash, Nonce, TransactionSignature, TransactionVersion};
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(
feature = "testing",
derive(serde::Deserialize, PartialEq, Eq),
serde(deny_unknown_fields)
)]
pub struct DeclareTransactionV3 {
version: TransactionVersion,
pub(crate) signature: TransactionSignature,
nonce: Nonce,
resource_bounds: ResourceBoundsWrapper,
tip: Tip,
paymaster_data: Vec<Felt>,
nonce_data_availability_mode: DataAvailabilityMode,
fee_data_availability_mode: DataAvailabilityMode,
pub(crate) sender_address: ContractAddress,
compiled_class_hash: CompiledClassHash,
class_hash: ClassHash,
account_deployment_data: Vec<Felt>,
}
impl DeclareTransactionV3 {
pub fn new(broadcasted_txn: &BroadcastedDeclareTransactionV3, class_hash: ClassHash) -> Self {
Self {
version: broadcasted_txn.common.version,
signature: broadcasted_txn.common.signature.clone(),
nonce: broadcasted_txn.common.nonce,
resource_bounds: broadcasted_txn.common.resource_bounds.clone(),
tip: broadcasted_txn.common.tip,
paymaster_data: broadcasted_txn.common.paymaster_data.clone(),
nonce_data_availability_mode: broadcasted_txn.common.nonce_data_availability_mode,
fee_data_availability_mode: broadcasted_txn.common.fee_data_availability_mode,
sender_address: broadcasted_txn.sender_address,
account_deployment_data: broadcasted_txn.account_deployment_data.clone(),
compiled_class_hash: broadcasted_txn.compiled_class_hash,
class_hash,
}
}
pub fn get_class_hash(&self) -> &ClassHash {
&self.class_hash
}
pub(crate) fn get_resource_bounds(&self) -> &ResourceBoundsWrapper {
&self.resource_bounds
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/transactions/broadcasted_invoke_transaction_v3.rs | crates/starknet-devnet-types/src/rpc/transactions/broadcasted_invoke_transaction_v3.rs | use std::sync::Arc;
use serde::Deserialize;
use starknet_rs_core::types::Felt;
use super::BroadcastedTransactionCommonV3;
use crate::contract_address::ContractAddress;
use crate::error::DevnetResult;
use crate::felt::Calldata;
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BroadcastedInvokeTransactionV3 {
#[serde(flatten)]
pub common: BroadcastedTransactionCommonV3,
pub sender_address: ContractAddress,
pub calldata: Calldata,
pub account_deployment_data: Vec<Felt>,
}
impl BroadcastedInvokeTransactionV3 {
pub fn create_sn_api_invoke(
&self,
) -> DevnetResult<starknet_api::transaction::InvokeTransaction> {
let sn_api_transaction = starknet_api::transaction::InvokeTransactionV3 {
resource_bounds: (&self.common.resource_bounds).into(),
tip: self.common.tip,
signature: starknet_api::transaction::fields::TransactionSignature(Arc::new(
self.common.signature.clone(),
)),
nonce: starknet_api::core::Nonce(self.common.nonce),
sender_address: self.sender_address.into(),
calldata: starknet_api::transaction::fields::Calldata(Arc::new(self.calldata.clone())),
nonce_data_availability_mode: self.common.nonce_data_availability_mode,
fee_data_availability_mode: self.common.fee_data_availability_mode,
paymaster_data: starknet_api::transaction::fields::PaymasterData(
self.common.paymaster_data.clone(),
),
account_deployment_data: starknet_api::transaction::fields::AccountDeploymentData(
self.account_deployment_data.clone(),
),
};
Ok(starknet_api::transaction::InvokeTransaction::V3(sn_api_transaction))
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/contract_class/deprecated/mod.rs | crates/starknet-devnet-types/src/rpc/contract_class/deprecated/mod.rs | use serde::{Deserialize, Deserializer, Serialize, Serializer};
use starknet_rs_core::types::{CompressedLegacyContractClass, Felt};
use crate::contract_class::deprecated::json_contract_class::Cairo0Json;
use crate::contract_class::deprecated::rpc_contract_class::DeprecatedContractClass;
use crate::error::{DevnetResult, Error};
use crate::traits::HashProducer;
pub mod abi_entry;
pub mod json_contract_class;
pub mod rpc_contract_class;
#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Cairo0ContractClass {
// TODO: remove once starknet_api raised
RawJson(Cairo0Json),
Rpc(DeprecatedContractClass),
}
impl Serialize for Cairo0ContractClass {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Cairo0ContractClass::RawJson(contract_json) => contract_json.serialize(serializer),
Cairo0ContractClass::Rpc(contract) => contract.serialize(serializer),
}
}
}
impl<'de> Deserialize<'de> for Cairo0ContractClass {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
Ok(Cairo0ContractClass::Rpc(DeprecatedContractClass::deserialize(deserializer)?))
}
}
impl From<Cairo0Json> for Cairo0ContractClass {
fn from(value: Cairo0Json) -> Self {
Cairo0ContractClass::RawJson(value)
}
}
impl From<DeprecatedContractClass> for Cairo0ContractClass {
fn from(value: DeprecatedContractClass) -> Self {
Cairo0ContractClass::Rpc(value)
}
}
impl HashProducer for Cairo0ContractClass {
type Error = Error;
fn generate_hash(&self) -> DevnetResult<Felt> {
match self {
Cairo0ContractClass::RawJson(contract_json) => Ok(contract_json.generate_hash()?),
Cairo0ContractClass::Rpc(contract) => Ok(contract.generate_hash()?),
}
}
}
impl TryInto<CompressedLegacyContractClass> for Cairo0ContractClass {
type Error = Error;
fn try_into(self) -> Result<CompressedLegacyContractClass, Self::Error> {
match self {
Cairo0ContractClass::Rpc(contract_class) => contract_class.try_into(),
Cairo0ContractClass::RawJson(contract_class) => contract_class.try_into(),
}
}
}
impl TryFrom<Cairo0ContractClass> for starknet_api::deprecated_contract_class::ContractClass {
type Error = Error;
fn try_from(value: Cairo0ContractClass) -> Result<Self, Self::Error> {
match value {
Cairo0ContractClass::RawJson(contract_class) => contract_class.try_into(),
Cairo0ContractClass::Rpc(contract_class) => contract_class.try_into(),
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/contract_class/deprecated/abi_entry.rs | crates/starknet-devnet-types/src/rpc/contract_class/deprecated/abi_entry.rs | use serde::{Deserialize, Deserializer, Serialize};
#[derive(Debug, Copy, Clone, Eq, PartialEq, Deserialize, Serialize, Default)]
pub enum AbiEntryType {
#[serde(rename(deserialize = "constructor", serialize = "constructor"))]
Constructor,
#[serde(rename(deserialize = "event", serialize = "event"))]
Event,
#[serde(rename(deserialize = "function", serialize = "function"))]
#[default]
Function,
#[serde(rename(deserialize = "l1_handler", serialize = "l1_handler"))]
L1Handler,
#[serde(rename(deserialize = "struct", serialize = "struct"))]
Struct,
}
#[derive(Debug, Clone, Eq, PartialEq, Serialize)]
#[serde(untagged)]
pub enum AbiEntry {
/// An event abi entry.
Event(EventAbiEntry),
/// A function abi entry.
Function(FunctionAbiEntry),
/// A struct abi entry.
Struct(StructAbiEntry),
}
#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
pub struct EventAbiEntry {
pub data: Vec<starknet_api::deprecated_contract_class::TypedParameter>,
pub keys: Vec<starknet_api::deprecated_contract_class::TypedParameter>,
pub name: String,
}
/// A struct abi entry.
#[derive(Debug, Clone, Default, Eq, PartialEq, Deserialize, Serialize)]
pub struct StructAbiEntry {
pub members: Vec<StructMember>,
pub name: String,
pub size: usize,
}
/// A struct member for [StructAbiEntry](`crate::deprecated_contract_class::StructAbiEntry`).
#[derive(Debug, Clone, Default, Eq, PartialEq, Deserialize, Serialize)]
pub struct StructMember {
pub name: String,
pub offset: usize,
pub r#type: String,
}
#[derive(Debug, Clone, Default, Eq, PartialEq, Deserialize, Serialize)]
pub struct FunctionAbiEntry {
pub inputs: Vec<starknet_api::deprecated_contract_class::TypedParameter>,
pub name: String,
pub outputs: Vec<starknet_api::deprecated_contract_class::TypedParameter>,
#[serde(skip_serializing_if = "Option::is_none")]
#[serde(rename = "stateMutability")]
pub state_mutability: Option<String>,
}
impl<'de> Deserialize<'de> for AbiEntry {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let raw_value = serde_json::Value::deserialize(deserializer)?;
if raw_value.get("data").is_some() {
let entry = serde_json::from_value(raw_value)
.map_err(|e| serde::de::Error::custom(format!("Invalid event ABI entry: {e}")))?;
Ok(AbiEntry::Event(entry))
} else if raw_value.get("members").is_some() {
let entry = serde_json::from_value(raw_value)
.map_err(|e| serde::de::Error::custom(format!("Invalid struct ABI entry: {e}")))?;
Ok(AbiEntry::Struct(entry))
} else if raw_value.get("inputs").is_some() {
let entry = serde_json::from_value(raw_value).map_err(|e| {
serde::de::Error::custom(format!("Invalid function ABI entry: {e}"))
})?;
Ok(AbiEntry::Function(entry))
} else {
Err(serde::de::Error::custom(format!("Invalid ABI entry: {raw_value}")))
}
}
}
#[cfg(test)]
mod tests {
use super::FunctionAbiEntry;
#[test]
fn deserialize_function_abi_entry() {
let json_str = r#"{
"name": "foo",
"inputs": [
{
"name": "bar",
"type": "uint256"
}
],
"outputs": [
{
"name": "baz",
"type": "uint256"
}
],
"stateMutability": "view"
}"#;
serde_json::from_str::<FunctionAbiEntry>(json_str).unwrap();
let json_str = r#"{
"name": "foo",
"inputs": [
{
"name": "bar",
"type": "uint256"
}
],
"outputs": [
{
"name": "baz",
"type": "uint256"
}
]
}"#;
serde_json::from_str::<FunctionAbiEntry>(json_str).unwrap();
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/contract_class/deprecated/json_contract_class.rs | crates/starknet-devnet-types/src/rpc/contract_class/deprecated/json_contract_class.rs | use core::fmt::{Debug, Display, Formatter};
use std::collections::HashMap;
use flate2::Compression;
use flate2::write::GzEncoder;
use serde::{Deserialize, Serialize};
use serde_json::{Serializer as JsonSerializer, Value, json};
use starknet_api::contract_class::EntryPointType;
use starknet_api::deprecated_contract_class::EntryPointV0;
use starknet_rs_core::types::{CompressedLegacyContractClass, Felt};
use starknet_types_core::hash::{Pedersen, StarkHash};
use crate::contract_class::deprecated::rpc_contract_class::DeprecatedContractClass;
use crate::error::{ConversionError, DevnetResult, Error, JsonError};
use crate::felt::felt_from_prefixed_hex;
use crate::traits::HashProducer;
use crate::utils::StarknetFormatter;
#[derive(Clone, Eq, PartialEq, Debug, Default, Serialize, Deserialize)]
pub struct Cairo0Json {
pub inner: Value,
}
impl Cairo0Json {
pub fn raw_json_from_json_str(json_str: &str) -> DevnetResult<Cairo0Json> {
let value: Value = serde_json::from_str(json_str).map_err(JsonError::SerdeJsonError)?;
if value.is_object() {
Ok(Cairo0Json { inner: value })
} else {
Err(Error::JsonError(JsonError::Custom {
msg: "expected JSON string to be an object".to_string(),
}))
}
}
pub fn raw_json_from_path(path: &str) -> DevnetResult<Cairo0Json> {
let contract_class_str = std::fs::read_to_string(path)?;
Cairo0Json::raw_json_from_json_str(&contract_class_str)
}
/// Computes the hinted class hash of the contract class.
/// The parameter is a JSON object representing the contract class.
/// Pythonic hinted class hash computation is based on a JSON artifact produced by the
/// cairo-lang compiler. The JSON object contains his keys in alphabetical order. But when
/// those keys are made of digits only, they are sorted in ascending order. For example keys
/// "1", "10", "2" are sorted as "1", "2", "10" and keys "b", "a", "c" are sorted as "a", "b",
/// "c". The resulting object is being serialized to a string and then hashed.
/// In rust serde_json library when deserializing a JSON object, internally it uses a Map either
/// HashMap or IndexMap. Depending on the feature enabled if [preserver_order] is not enabled
/// HashMap will be used. In HashMap the keys order of insertion is not preserved and they
/// are sorted alphabetically, which doesn't work for our case, because the contract artifact
/// contains keys under the "hints" property that are only numbers. So we use IndexMap to
/// preserve order of the keys, but its disadvantage is removing entries from the json object,
/// because it uses swap_remove method on IndexMap, which doesn't preserve order.
/// So we traverse the JSON object and remove all entries with key - attributes or
/// accessible_scopes if they are empty arrays.
fn compute_hinted_class_hash(contract_class: &Value) -> crate::error::DevnetResult<Felt> {
let mut abi_program_json = json!({
"abi": contract_class.get("abi").unwrap_or(&Value::Null),
"program": contract_class.get("program").unwrap_or(&Value::Null)
});
let program_json = abi_program_json
.get_mut("program")
.ok_or(JsonError::Custom { msg: "missing program entry".to_string() })?;
let debug_info_json = program_json.get_mut("debug_info");
if debug_info_json.is_some() {
program_json
.as_object_mut()
.ok_or(JsonError::Custom { msg: "expected object".to_string() })?
.insert("debug_info".to_string(), serde_json::Value::Null);
}
// Traverse the JSON and remove all entries with key attributes and accessible_scopes
// if they are empty arrays.
let modified_abi_program_json =
crate::utils::traverse_and_exclude_recursively(&abi_program_json, &|key, value| {
match value.as_array() {
Some(array) if array.is_empty() => {
key == "attributes" || key == "accessible_scopes"
}
_ => false,
}
});
let mut buffer = Vec::with_capacity(128);
let mut serializer = JsonSerializer::with_formatter(&mut buffer, StarknetFormatter);
modified_abi_program_json.serialize(&mut serializer).map_err(JsonError::SerdeJsonError)?;
Ok(starknet_rs_core::utils::starknet_keccak(&buffer))
}
fn compute_cairo_0_contract_class_hash(json_class: &Value) -> crate::error::DevnetResult<Felt> {
let mut hashes = vec![Felt::ZERO];
let entry_points_by_type: HashMap<EntryPointType, Vec<EntryPointV0>> =
serde_json::from_value(
json_class
.get("entry_points_by_type")
.ok_or(JsonError::Custom {
msg: "missing entry_points_by_type entry".to_string(),
})?
.clone(),
)
.map_err(JsonError::SerdeJsonError)?;
let entry_points_hash_by_type = |entry_point_type: EntryPointType| -> DevnetResult<Felt> {
let felts: Vec<Felt> = entry_points_by_type
.get(&entry_point_type)
.ok_or(ConversionError::InvalidInternalStructure(
"Missing entry point type".to_string(),
))?
.iter()
.flat_map(|entry_point| {
let selector = entry_point.selector.0;
let offset = Felt::from(entry_point.offset.0 as u128);
vec![selector, offset]
})
.collect();
Ok(Pedersen::hash_array(&felts))
};
hashes.push(entry_points_hash_by_type(EntryPointType::External)?);
hashes.push(entry_points_hash_by_type(EntryPointType::L1Handler)?);
hashes.push(entry_points_hash_by_type(EntryPointType::Constructor)?);
let program_json = json_class
.get("program")
.ok_or(JsonError::Custom { msg: "missing program entry".to_string() })?;
let builtins_encoded_as_felts = program_json
.get("builtins")
.and_then(|v| v.as_array())
.unwrap_or(&vec![])
.iter()
.map(|el| {
el.as_str()
.map(|s| {
let hex_str = s
.as_bytes()
.iter()
.fold(String::from("0x"), |acc, &b| format!("{acc}{:02x}", b));
felt_from_prefixed_hex(&hex_str)
})
.ok_or(JsonError::Custom { msg: "expected string".into() })?
})
.collect::<DevnetResult<Vec<Felt>>>()?;
hashes.push(Pedersen::hash_array(&builtins_encoded_as_felts));
hashes.push(Cairo0Json::compute_hinted_class_hash(json_class)?);
let program_data_felts = program_json
.get("data")
.unwrap_or(&serde_json::Value::Null)
.as_array()
.unwrap_or(&Vec::<serde_json::Value>::new())
.clone()
.into_iter()
.map(|v| {
felt_from_prefixed_hex(
v.as_str().ok_or(JsonError::Custom { msg: "expected string".into() })?,
)
})
.collect::<DevnetResult<Vec<Felt>>>()?;
hashes.push(Pedersen::hash_array(&program_data_felts));
Ok(Pedersen::hash_array(&hashes))
}
}
impl Display for Cairo0Json {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
Display::fmt(&self.inner, f)
}
}
impl TryInto<CompressedLegacyContractClass> for Cairo0Json {
type Error = Error;
fn try_into(self) -> Result<CompressedLegacyContractClass, Self::Error> {
let value = self.inner;
let abi = value.get("abi");
let entry_points_by_type = value
.get("entry_points_by_type")
.ok_or(JsonError::Custom { msg: "expected object".to_string() })?;
let program =
value.get("program").ok_or(JsonError::Custom { msg: "expected object".to_string() })?;
let compressed_program = json_into_raw_program(program)?;
match abi {
Some(abi_json) => Ok(CompressedLegacyContractClass {
program: compressed_program,
entry_points_by_type: serde_json::from_value(entry_points_by_type.clone())
.map_err(JsonError::SerdeJsonError)?,
abi: serde_json::from_value(abi_json.clone()).map_err(JsonError::SerdeJsonError)?,
}),
None => Ok(CompressedLegacyContractClass {
program: compressed_program,
entry_points_by_type: serde_json::from_value(entry_points_by_type.clone())
.map_err(JsonError::SerdeJsonError)?,
abi: None,
}),
}
}
}
impl HashProducer for Cairo0Json {
type Error = Error;
fn generate_hash(&self) -> DevnetResult<Felt> {
Cairo0Json::compute_cairo_0_contract_class_hash(&self.inner)
}
}
impl TryFrom<DeprecatedContractClass> for Cairo0Json {
type Error = Error;
fn try_from(value: DeprecatedContractClass) -> Result<Self, Self::Error> {
let abi_json = serde_json::to_value(value.abi).map_err(JsonError::SerdeJsonError)?;
let entry_points_json =
serde_json::to_value(value.entry_points_by_type).map_err(JsonError::SerdeJsonError)?;
let json_value = json!({
"program": value.program,
"abi": abi_json,
"entry_points_by_type": entry_points_json,
});
Ok(Cairo0Json { inner: json_value })
}
}
impl TryFrom<Cairo0Json> for starknet_api::deprecated_contract_class::ContractClass {
type Error = Error;
fn try_from(value: Cairo0Json) -> Result<Self, Self::Error> {
serde_json::from_value(value.inner)
.map_err(|err| Error::JsonError(JsonError::SerdeJsonError(err)))
}
}
pub fn json_into_raw_program(json_data: &Value) -> DevnetResult<Vec<u8>> {
let mut buffer = Vec::new();
let encoder = GzEncoder::new(&mut buffer, Compression::best());
serde_json::to_writer(encoder, &json_data).map_err(JsonError::SerdeJsonError)?;
Ok(buffer)
}
#[cfg(test)]
mod tests {
use starknet_rs_core::types::CompressedLegacyContractClass;
use crate::contract_class::deprecated::Cairo0Json;
use crate::utils::test_utils::CAIRO_0_ACCOUNT_CONTRACT_PATH;
#[test]
fn test_unzipped_to_codegen_conversion() {
let class = Cairo0Json::raw_json_from_path(CAIRO_0_ACCOUNT_CONTRACT_PATH).unwrap();
let _: CompressedLegacyContractClass = class.try_into().unwrap();
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-types/src/rpc/contract_class/deprecated/rpc_contract_class.rs | crates/starknet-devnet-types/src/rpc/contract_class/deprecated/rpc_contract_class.rs | use serde::{Deserialize, Serialize};
use serde_json::Value;
use starknet_rs_core::types::{CompressedLegacyContractClass, Felt, LegacyEntryPointsByType};
use crate::contract_class::deprecated::Cairo0Json;
use crate::contract_class::deprecated::abi_entry::{AbiEntry, AbiEntryType};
use crate::error::{DevnetResult, Error, JsonError};
use crate::serde_helpers::base_64_gzipped_json_string::{
deserialize_to_serde_json_value_with_keys_ordered_in_alphabetical_order,
serialize_program_to_base64,
};
use crate::traits::HashProducer;
#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
pub struct ContractClassAbiEntryWithType {
#[serde(flatten)]
pub entry: AbiEntry,
pub r#type: AbiEntryType,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct DeprecatedContractClass {
/// A base64 encoding of the gzip-compressed JSON representation of program.
#[serde(
deserialize_with = "deserialize_to_serde_json_value_with_keys_ordered_in_alphabetical_order",
serialize_with = "serialize_program_to_base64"
)]
pub program: Value,
pub abi: Vec<ContractClassAbiEntryWithType>,
/// The selector of each entry point is a unique identifier in the program.
pub entry_points_by_type: LegacyEntryPointsByType,
}
impl DeprecatedContractClass {
pub fn rpc_from_json_str(json_str: &str) -> DevnetResult<DeprecatedContractClass> {
let res: DeprecatedContractClass =
serde_json::from_str(json_str).map_err(JsonError::SerdeJsonError)?;
Ok(res)
}
pub fn rpc_from_path(path: &str) -> DevnetResult<DeprecatedContractClass> {
let contract_class_str = std::fs::read_to_string(path)?;
DeprecatedContractClass::rpc_from_json_str(&contract_class_str)
}
}
impl PartialEq for DeprecatedContractClass {
fn eq(&self, other: &Self) -> bool {
self.program == other.program && self.abi == other.abi
}
}
impl Eq for DeprecatedContractClass {}
impl Default for DeprecatedContractClass {
fn default() -> Self {
Self {
program: Value::default(),
abi: Vec::new(),
entry_points_by_type: LegacyEntryPointsByType {
constructor: Vec::new(),
external: Vec::new(),
l1_handler: Vec::new(),
},
}
}
}
impl HashProducer for DeprecatedContractClass {
type Error = Error;
fn generate_hash(&self) -> DevnetResult<Felt> {
let json_value: Cairo0Json = self.clone().try_into()?;
json_value.generate_hash()
}
}
impl TryInto<CompressedLegacyContractClass> for DeprecatedContractClass {
type Error = Error;
fn try_into(self) -> Result<CompressedLegacyContractClass, Self::Error> {
// TODO: improve
let cairo0: Cairo0Json = self.try_into()?;
cairo0.try_into()
}
}
impl TryFrom<DeprecatedContractClass> for starknet_api::deprecated_contract_class::ContractClass {
type Error = Error;
fn try_from(value: DeprecatedContractClass) -> Result<Self, Self::Error> {
let cairo_0_json = Cairo0Json::try_from(value)?;
cairo_0_json.try_into()
}
}
#[cfg(test)]
mod tests {
use starknet_rs_core::types::CompressedLegacyContractClass;
use crate::contract_class::deprecated::DeprecatedContractClass;
use crate::utils::test_utils::CAIRO_0_RPC_CONTRACT_PATH;
#[test]
fn test_rpc_deserialization() {
DeprecatedContractClass::rpc_from_path(CAIRO_0_RPC_CONTRACT_PATH).unwrap();
}
#[test]
fn test_rpc_to_codegen() {
let contract_class =
DeprecatedContractClass::rpc_from_path(CAIRO_0_RPC_CONTRACT_PATH).unwrap();
let _: CompressedLegacyContractClass = contract_class.try_into().unwrap();
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/lib.rs | crates/starknet-devnet-core/src/lib.rs | pub mod account;
mod blocks;
pub mod constants;
pub mod contract_class_choice;
pub mod error;
pub mod messaging;
mod predeployed_accounts;
pub mod starknet;
mod state;
mod system_contract;
mod traits;
mod transactions;
pub use utils::random_number_generator;
#[cfg(not(feature = "test_utils"))]
mod utils;
#[cfg(feature = "test_utils")]
pub mod utils;
pub use blocks::StarknetBlock;
pub use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/transactions.rs | crates/starknet-devnet-core/src/transactions.rs | use blockifier::execution::call_info::CallInfo;
use blockifier::execution::stack_trace::ErrorStack;
use blockifier::transaction::objects::TransactionExecutionInfo;
use indexmap::IndexMap;
use starknet_api::block::BlockNumber;
use starknet_rs_core::types::ExecutionResult;
use starknet_types::contract_address::ContractAddress;
use starknet_types::emitted_event::{Event, OrderedEvent};
use starknet_types::felt::{BlockHash, TransactionHash};
use starknet_types::messaging::MessageToL2;
use starknet_types::rpc::messaging::{MessageToL1, OrderedMessageToL1};
use starknet_types::rpc::transaction_receipt::{
DeployAccountTransactionReceipt, FeeAmount, FeeInUnits, L1HandlerTransactionReceipt,
TransactionReceipt,
};
use starknet_types::rpc::transactions::{
DeclareTransaction, DeployAccountTransaction, InvokeTransaction, Transaction,
TransactionFinalityStatus, TransactionStatus, TransactionTrace, TransactionWithHash,
};
use crate::error::DevnetResult;
use crate::traits::{HashIdentified, HashIdentifiedMut};
#[derive(Default)]
pub struct StarknetTransactions(IndexMap<TransactionHash, StarknetTransaction>);
impl StarknetTransactions {
pub fn insert(&mut self, transaction_hash: &TransactionHash, transaction: StarknetTransaction) {
self.0.insert(*transaction_hash, transaction);
}
pub fn get(&self, transaction_hash: &TransactionHash) -> Option<&StarknetTransaction> {
self.0.get(transaction_hash)
}
pub fn remove(&mut self, transaction_hash: &TransactionHash) -> Option<StarknetTransaction> {
self.0.shift_remove(transaction_hash)
}
}
impl HashIdentifiedMut for StarknetTransactions {
type Hash = TransactionHash;
type Element = StarknetTransaction;
fn get_by_hash_mut(&mut self, hash: &Self::Hash) -> Option<&mut StarknetTransaction> {
self.0.get_mut(hash)
}
}
impl HashIdentified for StarknetTransactions {
type Hash = TransactionHash;
type Element = StarknetTransaction;
fn get_by_hash(&self, hash: Self::Hash) -> Option<&StarknetTransaction> {
self.0.get(&hash)
}
}
#[derive(Debug)]
pub struct StarknetTransaction {
pub inner: TransactionWithHash,
pub(crate) finality_status: TransactionFinalityStatus,
pub(crate) execution_result: ExecutionResult,
pub(crate) block_hash: Option<BlockHash>,
pub(crate) block_number: Option<BlockNumber>,
pub(crate) execution_info: TransactionExecutionInfo,
pub(crate) trace: Option<TransactionTrace>,
}
impl StarknetTransaction {
pub fn pre_confirm(
transaction: &TransactionWithHash,
execution_info: TransactionExecutionInfo,
trace: TransactionTrace,
pre_confirmed_block_number: BlockNumber,
) -> Self {
Self {
finality_status: TransactionFinalityStatus::PreConfirmed,
execution_result: match execution_info.is_reverted() {
true => ExecutionResult::Reverted {
reason: execution_info
.revert_error
.as_ref()
.unwrap_or(&ErrorStack::default().into())
.to_string(),
},
false => ExecutionResult::Succeeded,
},
inner: transaction.clone(),
block_hash: None,
block_number: Some(pre_confirmed_block_number),
execution_info,
trace: Some(trace),
}
}
pub fn get_events(&self) -> Vec<Event> {
let mut events: Vec<Event> = vec![];
fn get_blockifier_events_recursively(
call_info: &blockifier::execution::call_info::CallInfo,
) -> Vec<(OrderedEvent, ContractAddress)> {
let mut events: Vec<(OrderedEvent, ContractAddress)> = vec![];
events.extend(
call_info
.execution
.events
.iter()
.map(|e| (OrderedEvent::from(e), call_info.call.storage_address.into())),
);
call_info.inner_calls.iter().for_each(|call| {
events.extend(get_blockifier_events_recursively(call));
});
events
}
let call_infos = vec![
self.execution_info.validate_call_info.as_ref(),
self.execution_info.execute_call_info.as_ref(),
self.execution_info.fee_transfer_call_info.as_ref(),
];
for inner_call_info in call_infos.into_iter().flatten() {
let mut not_sorted_events = get_blockifier_events_recursively(inner_call_info);
not_sorted_events.sort_by_key(|(ordered_event, _)| ordered_event.order);
events.extend(not_sorted_events.into_iter().map(|(ordered_event, address)| Event {
from_address: address,
keys: ordered_event.keys,
data: ordered_event.data,
}));
}
events
}
pub fn get_receipt(&self) -> DevnetResult<TransactionReceipt> {
let transaction_events = self.get_events();
let transaction_messages = self.get_l2_to_l1_messages();
// decide what units to set for actual fee.
// L1 Handler transactions are in WEI
// V3 transactions are in STRK(FRI)
// Other transactions versions are in ETH(WEI)
let fee_amount = FeeAmount { amount: self.execution_info.receipt.fee };
let actual_fee_in_units = match self.inner.transaction {
Transaction::L1Handler(_) => FeeInUnits::WEI(fee_amount),
Transaction::Declare(DeclareTransaction::V3(_))
| Transaction::DeployAccount(DeployAccountTransaction::V3(_))
| Transaction::Invoke(InvokeTransaction::V3(_)) => FeeInUnits::FRI(fee_amount),
_ => FeeInUnits::WEI(fee_amount),
};
let common_receipt = self.inner.create_common_receipt(
&transaction_events,
&transaction_messages,
self.block_hash.as_ref(),
self.block_number,
&self.execution_result,
self.finality_status,
actual_fee_in_units,
&self.execution_info,
);
match &self.inner.transaction {
Transaction::DeployAccount(deploy_account_txn) => {
Ok(TransactionReceipt::DeployAccount(DeployAccountTransactionReceipt {
common: common_receipt,
contract_address: *deploy_account_txn.get_contract_address(),
}))
}
Transaction::Invoke(_) => Ok(TransactionReceipt::Common(common_receipt)),
Transaction::L1Handler(l1_transaction) => {
let msg_hash = MessageToL2::try_from(l1_transaction)?.hash()?;
Ok(TransactionReceipt::L1Handler(L1HandlerTransactionReceipt {
common: common_receipt,
message_hash: msg_hash,
}))
}
_ => Ok(TransactionReceipt::Common(common_receipt)),
}
}
pub fn get_block_number(&self) -> Option<BlockNumber> {
self.block_number
}
pub fn get_status(&self) -> TransactionStatus {
TransactionStatus {
finality_status: self.finality_status,
failure_reason: self.execution_info.revert_error.as_ref().map(|err| err.to_string()),
execution_status: self.execution_result.status(),
}
}
pub fn get_trace(&self) -> Option<TransactionTrace> {
self.trace.clone()
}
pub fn get_l2_to_l1_messages(&self) -> Vec<MessageToL1> {
let mut messages = vec![];
fn get_blockifier_messages_recursively(call_info: &CallInfo) -> Vec<OrderedMessageToL1> {
let mut messages = vec![];
// Ensure we always take the address of the contract that is sending the message.
// In the case of a library syscall, storage address will automatically refer to the
// caller address.
let from_address = call_info.call.storage_address;
messages.extend(call_info.execution.l2_to_l1_messages.iter().map(|m| {
OrderedMessageToL1 {
order: m.order,
#[allow(clippy::expect_used)] // TODO
message: MessageToL1 {
to_address: m.message.to_address.try_into().expect("TODO"),
from_address: from_address.into(),
payload: m.message.payload.0.clone(),
},
}
}));
call_info.inner_calls.iter().for_each(|inner_call| {
messages.extend(get_blockifier_messages_recursively(inner_call));
});
messages
}
let call_infos = self.execution_info.non_optional_call_infos();
for inner_call_info in call_infos {
let mut not_sorted_messages = get_blockifier_messages_recursively(inner_call_info);
not_sorted_messages.sort_by_key(|message| message.order);
messages.extend(not_sorted_messages.into_iter().map(|m| m.message));
}
messages
}
}
impl From<&StarknetTransaction>
for starknet_api::block_hash::block_hash_calculator::TransactionHashingData
{
fn from(tx: &StarknetTransaction) -> Self {
Self {
transaction_signature: starknet_api::transaction::fields::TransactionSignature(
tx.inner.get_signature().into(),
),
transaction_hash: starknet_api::transaction::TransactionHash(
*tx.inner.get_transaction_hash(),
),
transaction_output:
starknet_api::block_hash::block_hash_calculator::TransactionOutputForHash {
actual_fee: tx.execution_info.receipt.fee,
events: tx
.get_events()
.iter()
.map(|f| starknet_api::transaction::Event {
from_address: f.from_address.into(),
content: starknet_api::transaction::EventContent {
keys: f
.keys
.iter()
.map(|k| starknet_api::transaction::EventKey(*k))
.collect(),
data: starknet_api::transaction::EventData(f.data.to_vec()),
},
})
.collect(),
execution_status: match &tx.execution_result {
starknet_rs_core::types::ExecutionResult::Succeeded => {
starknet_api::transaction::TransactionExecutionStatus::Succeeded
}
starknet_rs_core::types::ExecutionResult::Reverted { reason } => {
starknet_api::transaction::TransactionExecutionStatus::Reverted(
starknet_api::transaction::RevertedTransactionExecutionStatus {
revert_reason: reason.to_string(),
},
)
}
},
gas_consumed: tx.execution_info.receipt.gas,
messages_sent: tx
.get_l2_to_l1_messages()
.into_iter()
.map(|msg| {
let to_address_felt: starknet_rs_core::types::Felt =
msg.to_address.into();
starknet_api::transaction::MessageToL1 {
to_address: starknet_api::core::EthAddress::try_from(
to_address_felt,
)
.unwrap_or_default(), /* Default should never happen, felt is
* used just as a helper for type
* conversions */
payload: starknet_api::transaction::L2ToL1Payload(
msg.payload.to_vec(),
),
from_address: msg.from_address.into(),
}
})
.collect(),
},
}
}
}
#[cfg(test)]
mod tests {
use blockifier::blockifier_versioned_constants::VersionedConstants;
use blockifier::state::cached_state::CachedState;
use blockifier::transaction::objects::TransactionExecutionInfo;
use starknet_api::block::BlockNumber;
use starknet_api::transaction::fields::GasVectorComputationMode;
use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
use starknet_rs_core::types::TransactionExecutionStatus;
use starknet_types::rpc::transactions::{
TransactionFinalityStatus, TransactionTrace, TransactionWithHash,
};
use super::{StarknetTransaction, StarknetTransactions};
use crate::starknet::transaction_trace::create_trace;
use crate::state::state_readers::DictState;
use crate::traits::HashIdentifiedMut;
use crate::utils::test_utils::dummy_declare_tx_v3_with_hash;
fn dummy_trace(tx: &TransactionWithHash) -> TransactionTrace {
create_trace(
&mut CachedState::<DictState>::new(Default::default()),
tx.get_type(),
&Default::default(),
Default::default(),
VersionedConstants::latest_constants(),
&GasVectorComputationMode::All,
)
.unwrap()
}
#[test]
fn get_transaction_by_hash() {
let tx = dummy_declare_tx_v3_with_hash();
let trace = dummy_trace(&tx);
let block_number = BlockNumber(1);
let sn_tx = StarknetTransaction::pre_confirm(
&tx,
TransactionExecutionInfo::default(),
trace.clone(),
block_number,
);
let mut sn_txs = StarknetTransactions::default();
sn_txs.insert(
tx.get_transaction_hash(),
StarknetTransaction::pre_confirm(
&tx,
TransactionExecutionInfo::default(),
trace,
block_number,
),
);
let extracted_tran = sn_txs.get_by_hash_mut(tx.get_transaction_hash()).unwrap();
assert_eq!(sn_tx.block_hash, extracted_tran.block_hash);
assert_eq!(sn_tx.block_number, extracted_tran.block_number);
assert!(sn_tx.inner == extracted_tran.inner);
assert_eq!(sn_tx.finality_status, extracted_tran.finality_status);
assert_eq!(sn_tx.execution_info, extracted_tran.execution_info);
assert_eq!(sn_tx.block_number, Some(block_number));
}
#[test]
fn check_correct_successful_transaction_creation() {
let tx = dummy_declare_tx_v3_with_hash();
let trace = dummy_trace(&tx);
let block_number = BlockNumber(42);
let sn_tran = StarknetTransaction::pre_confirm(
&tx,
TransactionExecutionInfo::default(),
trace,
block_number,
);
assert_eq!(sn_tran.finality_status, TransactionFinalityStatus::PreConfirmed);
assert_eq!(sn_tran.execution_result.status(), TransactionExecutionStatus::Succeeded);
assert!(sn_tran.block_hash.is_none());
assert_eq!(sn_tran.block_number, Some(block_number));
assert_eq!(sn_tran.inner, tx);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/error.rs | crates/starknet-devnet-core/src/error.rs | use blockifier::execution::stack_trace::{
ErrorStack, ErrorStackHeader, ErrorStackSegment, PreambleType, gen_tx_execution_error_trace,
};
use blockifier::fee::fee_checks::FeeCheckError;
use blockifier::transaction::errors::{
TransactionExecutionError, TransactionFeeError, TransactionPreValidationError,
};
use starknet_api::core::Nonce;
use starknet_rs_core::types::Felt;
use starknet_types;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_storage_key::ContractStorageKey;
use starknet_types::rpc::block::BlockId;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum Error {
#[error(transparent)]
StarknetApiError(#[from] starknet_api::StarknetApiError),
#[error(transparent)]
StateError(#[from] StateError),
#[error(transparent)]
BlockifierStateError(#[from] blockifier::state::errors::StateError),
#[error("{0:?}")]
ContractExecutionError(ContractExecutionError),
#[error("Execution error in simulating transaction no. {failure_index}: {execution_error:?}")]
ContractExecutionErrorInSimulation {
failure_index: usize,
execution_error: ContractExecutionError,
},
#[error("Types error: {0}")]
TypesError(#[from] starknet_types::error::Error),
#[error("I/O error: {0}")]
IoError(#[from] std::io::Error),
#[error("Error when reading file {path}")]
ReadFileError { source: std::io::Error, path: String },
#[error("The file does not exist")]
FileNotFound,
#[error("Contract not found")]
ContractNotFound,
#[error(transparent)]
SignError(#[from] starknet_rs_signers::local_wallet::SignError),
#[error("No block found")]
NoBlock,
#[error("No state at block {block_id:?}; consider running with --state-archive-capacity full")]
NoStateAtBlock { block_id: BlockId },
#[error("Format error")]
FormatError,
#[error("No transaction found")]
NoTransaction,
#[error("Invalid transaction index in a block")]
InvalidTransactionIndexInBlock,
#[error("Unsupported transaction type")]
UnsupportedTransactionType,
#[error("{msg}")]
UnsupportedAction { msg: String },
#[error("Unexpected internal error: {msg}")]
UnexpectedInternalError { msg: String },
#[error("Failed to load ContractClass: {0}")]
ContractClassLoadError(String),
#[error("Deserialization error: {origin}")]
DeserializationError { origin: String },
#[error("Serialization error: {origin}")]
SerializationError { origin: String },
#[error("Serialization not supported: {obj_name}")]
SerializationNotSupported { obj_name: String },
#[error(transparent)]
TransactionValidationError(#[from] TransactionValidationError),
#[error(transparent)]
TransactionFeeError(blockifier::transaction::errors::TransactionFeeError),
#[error(transparent)]
MessagingError(#[from] MessagingError),
#[error("Transaction has no trace")]
NoTransactionTrace,
#[error("the compiled class hash did not match the one supplied in the transaction")]
CompiledClassHashMismatch,
#[error("{msg}")]
ClassAlreadyDeclared { msg: String },
#[error("Requested entrypoint does not exist in the contract")]
EntrypointNotFound,
#[error("Contract class size is too large")]
ContractClassSizeIsTooLarge,
}
impl From<starknet_types_core::felt::FromStrError> for Error {
fn from(value: starknet_types_core::felt::FromStrError) -> Self {
Self::UnexpectedInternalError { msg: value.to_string() }
}
}
#[derive(Debug, Error)]
pub enum StateError {
#[error("No class hash {0:x} found")]
NoneClassHash(Felt),
#[error("No compiled class hash found for class_hash {0:x}")]
NoneCompiledHash(Felt),
#[error("No casm class found for hash {0:x}")]
NoneCasmClass(Felt),
#[error("No contract state assigned for contact address: {0:x}")]
NoneContractState(ContractAddress),
#[error("No storage value assigned for: {0}")]
NoneStorage(ContractStorageKey),
}
#[derive(Debug, Error)]
pub enum TransactionValidationError {
#[error("The transaction's resources don't cover validation or the minimal transaction fee.")]
InsufficientResourcesForValidate,
#[error("Account transaction nonce is invalid.")]
InvalidTransactionNonce {
address: ContractAddress,
account_nonce: Nonce,
incoming_tx_nonce: Nonce,
},
#[error("Account balance is not enough to cover the transaction cost.")]
InsufficientAccountBalance,
#[error("Account validation failed: {reason}")]
ValidationFailure { reason: String },
}
impl From<TransactionExecutionError> for Error {
fn from(value: TransactionExecutionError) -> Self {
match value {
TransactionExecutionError::TransactionPreValidationError(err) => match *err {
TransactionPreValidationError::InvalidNonce {
address,
account_nonce,
incoming_tx_nonce,
} => Self::TransactionValidationError(
TransactionValidationError::InvalidTransactionNonce {
address: address.into(),
account_nonce,
incoming_tx_nonce,
},
),
TransactionPreValidationError::StateError(err) => {
Self::ContractExecutionError(err.to_string().into())
}
TransactionPreValidationError::TransactionFeeError(tx_fee_err) => {
Self::from(*tx_fee_err)
}
},
TransactionExecutionError::FeeCheckError(err) => err.into(),
TransactionExecutionError::TransactionFeeError(err) => (*err).into(),
TransactionExecutionError::ValidateTransactionError { .. } => {
TransactionValidationError::ValidationFailure { reason: value.to_string() }.into()
}
err @ TransactionExecutionError::DeclareTransactionError { .. } => {
Error::ClassAlreadyDeclared { msg: err.to_string() }
}
TransactionExecutionError::PanicInValidate { panic_reason } => {
TransactionValidationError::ValidationFailure { reason: panic_reason.to_string() }
.into()
}
other => Self::ContractExecutionError(other.into()),
}
}
}
impl From<FeeCheckError> for Error {
fn from(value: FeeCheckError) -> Self {
match value {
FeeCheckError::MaxGasAmountExceeded { .. } | FeeCheckError::MaxFeeExceeded { .. } => {
TransactionValidationError::InsufficientResourcesForValidate.into()
}
FeeCheckError::InsufficientFeeTokenBalance { .. } => {
TransactionValidationError::InsufficientAccountBalance.into()
}
}
}
}
impl From<TransactionFeeError> for Error {
fn from(value: TransactionFeeError) -> Self {
#[warn(clippy::wildcard_enum_match_arm)]
match value {
TransactionFeeError::FeeTransferError { .. }
| TransactionFeeError::MaxFeeTooLow { .. }
| TransactionFeeError::InsufficientResourceBounds { .. } => {
TransactionValidationError::InsufficientResourcesForValidate.into()
}
TransactionFeeError::MaxFeeExceedsBalance { .. }
| TransactionFeeError::ResourcesBoundsExceedBalance { .. }
| TransactionFeeError::GasBoundsExceedBalance { .. } => {
TransactionValidationError::InsufficientAccountBalance.into()
}
err @ (TransactionFeeError::CairoResourcesNotContainedInFeeCosts
| TransactionFeeError::ExecuteFeeTransferError(_)
| TransactionFeeError::InsufficientFee { .. }
| TransactionFeeError::MissingL1GasBounds
| TransactionFeeError::StateError(_)) => Error::TransactionFeeError(err),
}
}
}
#[derive(Debug, Error)]
pub enum MessagingError {
#[error(
"Message is not configured, ensure you've used `postman/load_l1_messaging_contract` \
endpoint first."
)]
NotConfigured,
#[error("An error has occurred during messages conversion: {0}.")]
ConversionError(String),
#[error("Alloy error: {0}.")]
AlloyError(String),
#[error("Message to L1 with hash {0} is not present (never received OR already consumed).")]
MessageToL1NotPresent(String),
#[error("L1 not compatible: {0}")]
IncompatibleL1(String),
}
pub type DevnetResult<T, E = Error> = Result<T, E>;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct InnerContractExecutionError {
pub contract_address: starknet_api::core::ContractAddress,
pub class_hash: Felt,
pub selector: Felt,
#[serde(skip)]
pub return_data: Retdata,
pub error: Box<ContractExecutionError>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ContractExecutionError {
/// Nested contract call stack trace frame.
Nested(InnerContractExecutionError),
/// Terminal error message.
Message(String),
}
impl From<String> for ContractExecutionError {
fn from(value: String) -> Self {
ContractExecutionError::Message(value)
}
}
use blockifier::execution::call_info::{CallInfo, Retdata};
use serde::{Deserialize, Serialize};
impl From<TransactionExecutionError> for ContractExecutionError {
fn from(value: TransactionExecutionError) -> Self {
let error_stack = gen_tx_execution_error_trace(&value);
error_stack.into()
}
}
fn preamble_type_to_error_msg(preamble_type: &PreambleType) -> &'static str {
match preamble_type {
PreambleType::CallContract => "Error in external contract",
PreambleType::LibraryCall => "Error in library call",
PreambleType::Constructor => "Error in constructor",
}
}
fn header_to_error_msg(header: &ErrorStackHeader) -> &'static str {
match header {
ErrorStackHeader::Constructor => "Constructor error",
ErrorStackHeader::Execution => "Execution error",
ErrorStackHeader::Validation => "Validation error",
ErrorStackHeader::None => "Unknown error",
}
}
/// [[[error inner] error outer] root]
impl From<ErrorStack> for ContractExecutionError {
fn from(error_stack: ErrorStack) -> Self {
let error_string = error_stack.to_string();
fn format_error(stringified_error: &str, error_cause: &str) -> String {
if stringified_error.is_empty() {
error_cause.to_string()
} else {
format!("{} {}", stringified_error, error_cause)
}
}
let mut recursive_error_option = Option::<ContractExecutionError>::None;
for frame in error_stack.stack.iter().rev() {
let stack_err = match frame {
ErrorStackSegment::Cairo1RevertSummary(revert_summary) => {
let mut recursive_error = ContractExecutionError::Message(format_error(
&error_string,
&serde_json::to_string(&revert_summary.last_retdata.0).unwrap_or_default(),
));
for trace in revert_summary.stack.iter().rev() {
recursive_error =
ContractExecutionError::Nested(InnerContractExecutionError {
contract_address: trace.contract_address,
class_hash: trace.class_hash.unwrap_or_default().0,
selector: trace.selector.0,
return_data: revert_summary.last_retdata.clone(),
error: Box::new(recursive_error),
});
}
recursive_error
}
// VMException frame is omitted, unless it's the last frame of the error stack. It
// doesn't produce any meaningful message to the developer.
ErrorStackSegment::Vm(vm) => recursive_error_option.take().unwrap_or(
ContractExecutionError::Message(format_error(&error_string, &String::from(vm))),
),
ErrorStackSegment::StringFrame(msg) => {
ContractExecutionError::Message(format_error("", msg.as_str()))
}
ErrorStackSegment::EntryPoint(entry_point_error_frame) => {
let error = recursive_error_option.take().unwrap_or_else(|| {
ContractExecutionError::Message(format_error(
&error_string,
preamble_type_to_error_msg(&entry_point_error_frame.preamble_type),
))
});
ContractExecutionError::Nested(InnerContractExecutionError {
contract_address: entry_point_error_frame.storage_address,
class_hash: entry_point_error_frame.class_hash.0,
selector: entry_point_error_frame.selector.unwrap_or_default().0,
return_data: Retdata(Vec::new()),
error: Box::new(error),
})
}
};
recursive_error_option = Some(stack_err);
}
if let Some(recursive_error) = recursive_error_option {
recursive_error
} else {
let error_msg = header_to_error_msg(&error_stack.header);
ContractExecutionError::Message(format_error(&error_string, error_msg))
}
}
}
impl From<&CallInfo> for ContractExecutionError {
fn from(call_info: &CallInfo) -> Self {
/// Traces recursively and returns elements starting from the deepest element
/// and then moves outward to the enclosing elements
fn collect_failed_calls(root_call: &CallInfo) -> Vec<&CallInfo> {
let mut calls = vec![];
for inner_call in root_call.inner_calls.iter() {
calls.extend(collect_failed_calls(inner_call));
}
if root_call.execution.failed {
calls.push(root_call);
}
calls
}
let failed_calls = collect_failed_calls(call_info);
// collects retdata of each CallInfo, starting from the outermost element of failed_calls
// collection and combines them in 1-dimensional array
// It serves as the reason for the failed call stack trace
let mut recursive_error = ContractExecutionError::Message(
serde_json::to_string(
&failed_calls
.iter()
.rev()
.flat_map(|f| f.execution.retdata.clone().0)
.collect::<Vec<Felt>>(),
)
.unwrap_or_default(),
);
for failed in failed_calls {
let current = ContractExecutionError::Nested(InnerContractExecutionError {
contract_address: failed.call.storage_address,
class_hash: failed.call.class_hash.unwrap_or_default().0,
selector: failed.call.entry_point_selector.0,
return_data: failed.execution.retdata.clone(),
error: Box::new(recursive_error),
});
recursive_error = current;
}
recursive_error
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/predeployed_accounts.rs | crates/starknet-devnet-core/src/predeployed_accounts.rs | use starknet_rs_signers::SigningKey;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use starknet_types::felt::{ClassHash, Key};
use starknet_types::rpc::state::Balance;
use crate::account::{Account, KeyPair};
use crate::error::DevnetResult;
use crate::traits::AccountGenerator;
use crate::utils::random_number_generator::generate_u128_random_numbers;
#[derive(Default)]
pub(crate) struct PredeployedAccounts {
seed: u32,
initial_balance: Balance,
eth_fee_token_address: ContractAddress,
strk_fee_token_address: ContractAddress,
accounts: Vec<Account>,
}
impl PredeployedAccounts {
pub(crate) fn new(
seed: u32,
initial_balance: Balance,
eth_fee_token_address: ContractAddress,
strk_fee_token_address: ContractAddress,
) -> Self {
Self {
seed,
initial_balance,
eth_fee_token_address,
strk_fee_token_address,
accounts: Vec::new(),
}
}
}
impl PredeployedAccounts {
fn generate_private_keys(&self, number_of_accounts: u8) -> Vec<Key> {
let random_numbers = generate_u128_random_numbers(self.seed, number_of_accounts);
random_numbers.into_iter().map(Key::from).collect::<Vec<Key>>()
}
fn generate_public_key(&self, private_key: &Key) -> Key {
Key::from(SigningKey::from_secret_scalar(*private_key).verifying_key().scalar())
}
pub fn get_accounts(&self) -> &Vec<Account> {
&self.accounts
}
}
impl AccountGenerator for PredeployedAccounts {
type Acc = Account;
fn generate_accounts(
&mut self,
number_of_accounts: u8,
class_hash: ClassHash,
contract_class: &ContractClass,
) -> DevnetResult<&Vec<Self::Acc>> {
let private_keys = self.generate_private_keys(number_of_accounts);
for private_key in private_keys {
let account = Account::new(
self.initial_balance.clone(),
KeyPair { public_key: self.generate_public_key(&private_key), private_key },
class_hash,
"Custom",
contract_class.clone(),
self.eth_fee_token_address,
self.strk_fee_token_address,
)?;
self.accounts.push(account);
}
Ok(&self.accounts)
}
}
#[cfg(test)]
mod tests {
use rand::{Rng, rng};
use starknet_types::rpc::state::Balance;
use crate::predeployed_accounts::PredeployedAccounts;
use crate::utils::test_utils::dummy_contract_address;
#[test]
fn private_key_from_equal_seeds_have_to_be_equal() {
for _ in 0..1000 {
let seed: u32 = rng().random();
let private_key1 = PredeployedAccounts::new(
seed,
Balance::from(1_u8),
dummy_contract_address(),
dummy_contract_address(),
)
.generate_private_keys(1)[0];
let private_key2 = PredeployedAccounts::new(
seed,
Balance::from(1_u8),
dummy_contract_address(),
dummy_contract_address(),
)
.generate_private_keys(1)[0];
assert_eq!(private_key1, private_key2);
}
}
#[test]
fn private_key_from_different_seeds_have_to_be_different() {
let mut rng = rng();
for _ in 0..1000 {
let mut seed1;
let mut seed2;
// get two different seeds
loop {
seed1 = rng.random::<u32>();
seed2 = rng.random::<u32>();
if seed1 != seed2 {
break;
}
}
let private_key1 = PredeployedAccounts::new(
seed1,
Balance::from(1_u8),
dummy_contract_address(),
dummy_contract_address(),
)
.generate_private_keys(1)[0];
let private_key2 = PredeployedAccounts::new(
seed2,
Balance::from(1_u8),
dummy_contract_address(),
dummy_contract_address(),
)
.generate_private_keys(1)[0];
assert_ne!(private_key1, private_key2);
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/utils.rs | crates/starknet-devnet-core/src/utils.rs | use blockifier::blockifier_versioned_constants::VersionedConstants;
use blockifier::bouncer::{BouncerConfig, BouncerWeights, BuiltinWeights};
use blockifier::transaction::objects::TransactionExecutionInfo;
use starknet_api::block::StarknetVersion;
use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
use starknet_rs_core::types::Felt;
use starknet_types::patricia_key::{PatriciaKey, StorageKey};
use crate::error::DevnetResult;
pub mod random_number_generator {
use rand::{Rng, SeedableRng, rng};
use rand_mt::Mt64;
pub fn generate_u32_random_number() -> u32 {
rng().random()
}
pub(crate) fn generate_u128_random_numbers(seed: u32, random_numbers_count: u8) -> Vec<u128> {
let mut result: Vec<u128> = Vec::new();
let mut rng: Mt64 = SeedableRng::seed_from_u64(seed as u64);
for _ in 0..random_numbers_count {
result.push(rng.random());
}
result
}
}
/// Returns the storage address of a Starknet storage variable given its name and arguments.
pub(crate) fn get_storage_var_address(
storage_var_name: &str,
args: &[Felt],
) -> DevnetResult<StorageKey> {
let storage_var_address =
starknet_rs_core::utils::get_storage_var_address(storage_var_name, args)
.map_err(|err| crate::error::Error::UnexpectedInternalError { msg: err.to_string() })?;
Ok(PatriciaKey::new(storage_var_address)?)
}
/// This should be modified when updating to the version after 0.14.1
pub(crate) fn get_versioned_constants() -> VersionedConstants {
#[allow(clippy::unwrap_used)]
VersionedConstants::get(&StarknetVersion::V0_14_1).unwrap().clone()
}
/// Values not present here: https://docs.starknet.io/tools/limits-and-triggers/
/// Asked the blockifier team about the values, they provided them in these threads:
/// https://spaceshard.slack.com/archives/C029F9AN8LX/p1721657837687799?thread_ts=1721400009.781699&cid=C029F9AN8LX
/// https://spaceshard.slack.com/archives/C029F9AN8LX/p1739259794326519?thread_ts=1738840494.497479&cid=C029F9AN8LX
/// https://spaceshard.slack.com/archives/C029F9AN8LX/p1750171661112469
/// https://spaceshard.slack.com/archives/C029F9AN8LX/p1750237658621529
pub(crate) fn custom_bouncer_config() -> BouncerConfig {
BouncerConfig {
block_max_capacity: BouncerWeights {
l1_gas: 4_950_000,
sierra_gas: starknet_api::execution_resources::GasAmount(2_000_000_000),
state_diff_size: 4_000,
n_events: 5_000,
..BouncerWeights::max()
},
builtin_weights: BuiltinWeights::default(),
blake_weight: 5263, // from BouncerConfig::default
}
}
#[macro_export]
macro_rules! nonzero_gas_price {
($value:expr) => {{
let gas_price = starknet_api::block::GasPrice(($value).get());
starknet_api::block::NonzeroGasPrice::new(gas_price).unwrap()
}};
}
pub(crate) fn maybe_extract_failure_reason(
execution_info: &TransactionExecutionInfo,
) -> Option<String> {
execution_info.revert_error.as_ref().map(|err| err.to_string())
}
#[cfg(test)]
pub(crate) mod test_utils {
use cairo_lang_starknet_classes::contract_class::ContractClass as SierraContractClass;
use starknet_api::data_availability::DataAvailabilityMode;
use starknet_api::transaction::fields::Tip;
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::deprecated::json_contract_class::Cairo0Json;
use starknet_types::contract_class::{Cairo0ContractClass, ContractClass};
use starknet_types::rpc::transactions::broadcasted_declare_transaction_v3::BroadcastedDeclareTransactionV3;
use starknet_types::rpc::transactions::broadcasted_invoke_transaction_v3::BroadcastedInvokeTransactionV3;
use starknet_types::rpc::transactions::declare_transaction_v3::DeclareTransactionV3;
use starknet_types::rpc::transactions::{
BroadcastedDeclareTransaction, BroadcastedInvokeTransaction,
BroadcastedTransactionCommonV3, DeclareTransaction, ResourceBoundsWrapper, Transaction,
TransactionWithHash,
};
use starknet_types::traits::HashProducer;
use crate::account::KeyPair;
use crate::constants::DEVNET_DEFAULT_CHAIN_ID;
pub(crate) fn dummy_felt() -> Felt {
Felt::from_hex_unchecked("0xDD10")
}
pub(crate) fn dummy_cairo_1_contract_class() -> SierraContractClass {
let json_str =
std::fs::read_to_string("../../contracts/test_artifacts/cairo1/cairo_1_test.sierra")
.unwrap();
ContractClass::cairo_1_from_sierra_json_str(&json_str).unwrap()
}
/// casm hash of dummy_cairo_1_contract_class
pub static DUMMY_CAIRO_1_COMPILED_CLASS_HASH: Felt = Felt::from_hex_unchecked(
"0x586026f886dd7ee74f6b32b12c9678f0bc090260c881a41d192103a17c110e8",
);
pub(crate) fn dummy_contract_address() -> ContractAddress {
ContractAddress::new(Felt::from_hex_unchecked("0xADD4E55")).unwrap()
}
/// Returns a gas bounds object with max amounts set to input params and prices set to 1
pub(crate) fn resource_bounds_with_price_1(
l1_gas: u64,
l1_data_gas: u64,
l2_gas: u64,
) -> ResourceBoundsWrapper {
ResourceBoundsWrapper::new(l1_gas, 1, l1_data_gas, 1, l2_gas, 1)
}
/// Returns an unsigned tx representing a v3 declaration of a predefined dummy
/// class. The tx can be sent to Starknet.
pub(crate) fn broadcasted_declare_tx_v3_of_dummy_class(
sender_address: ContractAddress,
nonce: Felt,
resource_bounds: ResourceBoundsWrapper,
) -> BroadcastedDeclareTransactionV3 {
broadcasted_declare_tx_v3(
sender_address,
nonce,
dummy_cairo_1_contract_class(),
DUMMY_CAIRO_1_COMPILED_CLASS_HASH,
resource_bounds,
)
}
/// Returns an unsigned tx representing a v3 declaration of the provided class. The
/// tx can be sent to Starknet.
pub(crate) fn broadcasted_declare_tx_v3(
sender_address: ContractAddress,
nonce: Felt,
contract_class: cairo_lang_starknet_classes::contract_class::ContractClass,
compiled_class_hash: Felt,
resource_bounds: ResourceBoundsWrapper,
) -> BroadcastedDeclareTransactionV3 {
BroadcastedDeclareTransactionV3 {
common: BroadcastedTransactionCommonV3 {
version: Felt::THREE,
signature: vec![],
nonce,
resource_bounds,
tip: Tip(0),
paymaster_data: vec![],
nonce_data_availability_mode: DataAvailabilityMode::L1,
fee_data_availability_mode: DataAvailabilityMode::L1,
},
contract_class,
sender_address,
compiled_class_hash,
account_deployment_data: vec![],
}
}
pub(crate) fn dummy_declare_tx_v3_with_hash() -> TransactionWithHash {
let declare_txn = broadcasted_declare_tx_v3_of_dummy_class(
dummy_contract_address(),
Felt::ZERO,
ResourceBoundsWrapper::new(
1, 1, // l1_gas
0, 0, // l1_data_gas
0, 0, // l2_gas
),
);
let sierra_hash =
ContractClass::Cairo1(declare_txn.contract_class.clone()).generate_hash().unwrap();
let tx_hash = BroadcastedDeclareTransaction::V3(Box::new(declare_txn.clone()))
.create_sn_api_declare(&DEVNET_DEFAULT_CHAIN_ID.to_felt())
.unwrap()
.tx_hash;
TransactionWithHash::new(
*tx_hash,
Transaction::Declare(DeclareTransaction::V3(DeclareTransactionV3::new(
&declare_txn,
sierra_hash,
))),
)
}
pub(crate) fn cairo_0_account_without_validations() -> Cairo0ContractClass {
let account_json_path =
"../../contracts/test_artifacts/cairo0/account_without_validations/account.json";
Cairo0Json::raw_json_from_path(account_json_path).unwrap().into()
}
pub fn dummy_key_pair() -> KeyPair {
KeyPair { public_key: dummy_felt(), private_key: dummy_felt() }
}
pub fn test_invoke_transaction_v3(
account_address: ContractAddress,
contract_address: ContractAddress,
function_selector: Felt,
params: &[Felt],
nonce: u128,
resource_bounds: ResourceBoundsWrapper,
) -> BroadcastedInvokeTransaction {
// Encode: [addr, selector, params len, *params]
let mut calldata = vec![Felt::from(contract_address), function_selector];
calldata.push(params.len().into());
calldata.extend_from_slice(params);
BroadcastedInvokeTransaction::V3(BroadcastedInvokeTransactionV3 {
common: BroadcastedTransactionCommonV3 {
version: Felt::THREE,
signature: vec![],
nonce: Felt::from(nonce),
resource_bounds,
tip: Tip(0),
paymaster_data: vec![],
nonce_data_availability_mode:
starknet_api::data_availability::DataAvailabilityMode::L1,
fee_data_availability_mode:
starknet_api::data_availability::DataAvailabilityMode::L1,
},
sender_address: account_address,
calldata,
account_deployment_data: vec![],
})
}
}
#[cfg(any(test, feature = "test_utils"))]
#[allow(clippy::unwrap_used)]
pub mod exported_test_utils {
use starknet_types::contract_class::Cairo0ContractClass;
use starknet_types::contract_class::deprecated::json_contract_class::Cairo0Json;
pub fn dummy_cairo_l1l2_contract() -> Cairo0ContractClass {
let json_str =
std::fs::read_to_string("../../contracts/test_artifacts/cairo0/l1l2.json").unwrap();
Cairo0Json::raw_json_from_json_str(&json_str).unwrap().into()
}
pub fn dummy_cairo_0_contract_class() -> Cairo0ContractClass {
let json_str =
std::fs::read_to_string("../../contracts/test_artifacts/cairo0/simple_contract.json")
.unwrap();
Cairo0Json::raw_json_from_json_str(&json_str).unwrap().into()
}
}
#[cfg(test)]
mod tests {
use super::get_storage_var_address;
use super::test_utils::{self};
#[test]
fn correct_simple_storage_var_address_generated() {
let expected_storage_var_address =
starknet_api::abi::abi_utils::get_storage_var_address("simple", &[]);
let generated_storage_var_address = get_storage_var_address("simple", &[]).unwrap();
assert_eq!(
expected_storage_var_address.0.key().to_bytes_be(),
generated_storage_var_address.to_felt().to_bytes_be()
);
}
#[test]
fn correct_complex_storage_var_address_generated() {
let expected_storage_var_address = starknet_api::abi::abi_utils::get_storage_var_address(
"complex",
&[test_utils::dummy_felt()],
);
let generated_storage_var_address =
get_storage_var_address("complex", &[test_utils::dummy_felt()]).unwrap();
assert_eq!(
expected_storage_var_address.0.key().to_bytes_be(),
generated_storage_var_address.to_felt().to_bytes_be()
);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/contract_class_choice.rs | crates/starknet-devnet-core/src/contract_class_choice.rs | use std::str::FromStr;
use starknet_rs_core::types::Felt;
use starknet_rs_core::utils::get_selector_from_name;
use starknet_types::contract_class::deprecated::json_contract_class::Cairo0Json;
use starknet_types::contract_class::{Cairo0ContractClass, ContractClass};
use starknet_types::traits::HashProducer;
use crate::constants::{CAIRO_0_ACCOUNT_CONTRACT, CAIRO_1_ACCOUNT_CONTRACT_SIERRA};
use crate::error::DevnetResult;
#[derive(clap::ValueEnum, Debug, Clone)]
pub enum AccountContractClassChoice {
Cairo0,
Cairo1,
}
impl AccountContractClassChoice {
pub fn get_class_wrapper(&self) -> DevnetResult<AccountClassWrapper> {
Ok(match self {
AccountContractClassChoice::Cairo0 => {
let contract_json = Cairo0Json::raw_json_from_json_str(CAIRO_0_ACCOUNT_CONTRACT)?;
let contract_class = Cairo0ContractClass::RawJson(contract_json);
AccountClassWrapper {
class_hash: contract_class.generate_hash()?,
contract_class: ContractClass::Cairo0(contract_class),
class_metadata: "OpenZeppelin 0.5.1",
}
}
AccountContractClassChoice::Cairo1 => {
let contract_class = ContractClass::Cairo1(
ContractClass::cairo_1_from_sierra_json_str(CAIRO_1_ACCOUNT_CONTRACT_SIERRA)?,
);
AccountClassWrapper {
class_hash: contract_class.generate_hash()?,
contract_class,
class_metadata: "OpenZeppelin 1.0.0",
}
}
})
}
}
#[derive(Clone, Debug)]
pub struct AccountClassWrapper {
pub contract_class: ContractClass,
pub class_hash: Felt,
pub class_metadata: &'static str,
}
impl FromStr for AccountClassWrapper {
type Err = crate::error::Error;
fn from_str(path_candidate: &str) -> Result<Self, Self::Err> {
// load artifact
let contract_class = ContractClass::cairo_1_from_sierra_json_str(
std::fs::read_to_string(path_candidate)?.as_str(),
)?;
// check that artifact is really account
let execute_selector = get_selector_from_name("__execute__")
.map_err(|err| crate::error::Error::UnexpectedInternalError { msg: err.to_string() })?;
let validate_selector = get_selector_from_name("__validate__")
.map_err(|err| crate::error::Error::UnexpectedInternalError { msg: err.to_string() })?;
let mut has_execute = false;
let mut has_validate = false;
for entry_point in &contract_class.entry_points_by_type.external {
let selector: Felt = (&entry_point.selector).into();
has_execute |= selector == execute_selector;
has_validate |= selector == validate_selector;
}
if !has_execute || !has_validate {
let msg = format!(
"Not a valid Sierra account artifact; has __execute__: {has_execute}; has \
__validate__: {has_validate}"
);
return Err(crate::error::Error::ContractClassLoadError(msg));
}
// generate the hash and return
let contract_class = ContractClass::Cairo1(contract_class);
let class_hash = contract_class.generate_hash()?;
Ok(Self { contract_class, class_hash, class_metadata: "Custom" })
}
}
#[cfg(test)]
mod tests {
use std::str::FromStr;
use clap::ValueEnum;
use starknet_types::felt::felt_from_prefixed_hex;
use starknet_types::traits::HashProducer;
use super::AccountContractClassChoice;
use crate::constants::{
CAIRO_0_ACCOUNT_CONTRACT_HASH, CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH,
CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH,
};
use crate::contract_class_choice::AccountClassWrapper;
#[test]
fn all_methods_work_with_all_options() {
for implementation in AccountContractClassChoice::value_variants().iter() {
let AccountClassWrapper { contract_class, class_hash, class_metadata } =
implementation.get_class_wrapper().unwrap();
let generated_hash = contract_class.generate_hash().unwrap();
assert_eq!(generated_hash, class_hash);
assert!(class_metadata.starts_with("OpenZeppelin"));
}
}
#[test]
fn correct_hash_calculated() {
assert_eq!(
AccountContractClassChoice::Cairo0.get_class_wrapper().unwrap().class_hash,
felt_from_prefixed_hex(CAIRO_0_ACCOUNT_CONTRACT_HASH).unwrap()
);
assert_eq!(
AccountContractClassChoice::Cairo1.get_class_wrapper().unwrap().class_hash,
felt_from_prefixed_hex(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH).unwrap()
)
}
#[test]
fn correct_metadata() {
assert_eq!(
AccountContractClassChoice::Cairo0.get_class_wrapper().unwrap().class_metadata,
"OpenZeppelin 0.5.1"
);
assert_eq!(
AccountContractClassChoice::Cairo1.get_class_wrapper().unwrap().class_metadata,
"OpenZeppelin 1.0.0"
);
let custom_class =
AccountClassWrapper::from_str(CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH).unwrap();
assert_eq!(custom_class.class_metadata, "Custom");
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/system_contract.rs | crates/starknet-devnet-core/src/system_contract.rs | use blockifier::state::state_api::StateReader;
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use starknet_types::contract_class::deprecated::json_contract_class::Cairo0Json;
use starknet_types::felt::ClassHash;
use starknet_types::rpc::state::Balance;
use crate::error::DevnetResult;
use crate::state::state_readers::DictState;
use crate::state::{CustomState, StarknetState};
use crate::traits::{Accounted, Deployed};
pub(crate) struct SystemContract {
class_hash: ClassHash,
address: ContractAddress,
contract_class: ContractClass,
}
impl SystemContract {
pub(crate) fn new_cairo0(
class_hash: Felt,
address: Felt,
contract_class_json_str: &str,
) -> DevnetResult<Self> {
Ok(Self {
class_hash,
address: ContractAddress::new(address)?,
contract_class: Cairo0Json::raw_json_from_json_str(contract_class_json_str)?.into(),
})
}
pub(crate) fn new_cairo1(
class_hash: ClassHash,
address: Felt,
contract_class_json_str: &str,
) -> DevnetResult<Self> {
Ok(Self {
class_hash,
address: ContractAddress::new(address)?,
contract_class: ContractClass::cairo_1_from_sierra_json_str(contract_class_json_str)?
.into(),
})
}
}
impl Deployed for SystemContract {
fn deploy(&self, state: &mut StarknetState) -> DevnetResult<()> {
self.declare_if_undeclared(state, self.class_hash, &self.contract_class)?;
state.predeploy_contract(self.address, self.class_hash)?;
Ok(())
}
fn get_address(&self) -> ContractAddress {
self.address
}
}
impl Accounted for SystemContract {
fn set_initial_balance(&self, _state: &mut DictState) -> DevnetResult<()> {
Ok(())
}
fn get_balance(
&self,
_state: &mut impl StateReader,
_token: crate::account::FeeToken,
) -> DevnetResult<Balance> {
Ok(Balance::default())
}
}
#[cfg(test)]
mod tests {
use starknet_types::contract_class::ContractClass;
use super::SystemContract;
use crate::constants::{
ETH_ERC20_CONTRACT_ADDRESS, ETH_ERC20_CONTRACT_CLASS, ETH_ERC20_CONTRACT_CLASS_HASH,
};
use crate::state::StarknetState;
use crate::traits::Deployed;
#[test]
fn load_erc20_contract() {
assert!(ContractClass::cairo_1_from_sierra_json_str(ETH_ERC20_CONTRACT_CLASS).is_ok());
}
#[test]
fn system_account_deployed_successfully() {
let mut state = StarknetState::default();
let sys_contract = SystemContract::new_cairo1(
ETH_ERC20_CONTRACT_CLASS_HASH,
ETH_ERC20_CONTRACT_ADDRESS,
ETH_ERC20_CONTRACT_CLASS,
)
.unwrap();
assert!(sys_contract.deploy(&mut state).is_ok());
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/constants.rs | crates/starknet-devnet-core/src/constants.rs | use std::net::{IpAddr, Ipv4Addr};
use std::num::NonZeroU128;
use nonzero_ext::nonzero;
use starknet_rs_core::types::Felt;
use starknet_types::chain_id::ChainId;
use starknet_types::num_bigint::BigUint;
pub const CAIRO_0_ACCOUNT_CONTRACT: &str = include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/contracts/accounts_artifacts/OpenZeppelin/0.5.1/Account.cairo/Account.json"
));
pub const CAIRO_0_ACCOUNT_CONTRACT_HASH: &str =
"0x4d07e40e93398ed3c76981e72dd1fd22557a78ce36c0515f679e27f0bb5bc5f";
/// only used in tests; if artifact needed in production, use CAIRO_1_ACCOUNT_CONTRACT_SIERRA
pub const CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH: &str = concat!(
env!("CARGO_MANIFEST_DIR"),
"/contracts/accounts_artifacts/OpenZeppelin/1.0.0/Account.cairo/Account.sierra"
);
pub const CAIRO_1_ACCOUNT_CONTRACT_SIERRA: &str = include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/contracts/accounts_artifacts/OpenZeppelin/1.0.0/Account.cairo/Account.sierra"
));
pub const CAIRO_1_ACCOUNT_CONTRACT_SIERRA_HASH: &str =
"0x05b4b537eaa2399e3aa99c4e2e0208ebd6c71bc1467938cd52c798c601e43564";
pub const ETH_ERC20_CONTRACT_CLASS_HASH: Felt =
Felt::from_hex_unchecked("0x9524a94b41c4440a16fd96d7c1ef6ad6f44c1c013e96662734502cd4ee9b1f");
pub const ETH_ERC20_CONTRACT_CLASS: &str = include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/contracts/system_artifacts/erc20_eth.sierra"
));
pub const ETH_ERC20_CONTRACT_ADDRESS: Felt =
Felt::from_hex_unchecked("0x49D36570D4E46F48E99674BD3FCC84644DDD6B96F7C741B1562B82F9E004DC7");
pub const STRK_ERC20_CONTRACT_CLASS_HASH: Felt =
Felt::from_hex_unchecked("0x76791ef97c042f81fbf352ad95f39a22554ee8d7927b2ce3c681f3418b5206a");
pub const STRK_ERC20_CONTRACT_CLASS: &str = include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/contracts/system_artifacts/erc20_strk.sierra"
));
pub const STRK_ERC20_CONTRACT_ADDRESS: Felt =
Felt::from_hex_unchecked("0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d");
// ERC20 contracts storage variables; available in source at https://github.com/starknet-io/starkgate-contracts
pub const ETH_ERC20_NAME: &str = "Ether";
pub const ETH_ERC20_SYMBOL: &str = "ETH";
pub const STRK_ERC20_NAME: &str = "StarkNet Token";
pub const STRK_ERC20_SYMBOL: &str = "STRK";
pub(crate) const UDC_LEGACY_CONTRACT: &str = include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/contracts/system_artifacts/UDC_OZ_0.5.0.json"
));
pub const UDC_LEGACY_CONTRACT_CLASS_HASH: Felt =
Felt::from_hex_unchecked("0x7B3E05F48F0C69E4A65CE5E076A66271A527AFF2C34CE1083EC6E1526997A69");
pub const UDC_LEGACY_CONTRACT_ADDRESS: Felt =
Felt::from_hex_unchecked("0x41A78E741E5AF2FEC34B695679BC6891742439F7AFB8484ECD7766661AD02BF");
pub(crate) const UDC_CONTRACT: &str =
include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/contracts/system_artifacts/udc_2.sierra"));
pub const UDC_CONTRACT_CLASS_HASH: Felt =
Felt::from_hex_unchecked("0x01b2df6d8861670d4a8ca4670433b2418d78169c2947f46dc614e69f333745c8");
pub const UDC_CONTRACT_ADDRESS: Felt =
Felt::from_hex_unchecked("0x02ceed65a4bd731034c01113685c831b01c15d7d432f71afb1cf1634b53a2125");
/// https://github.com/argentlabs/argent-contracts-starknet/blob/main/deployments/account.txt
pub const ARGENT_CONTRACT_VERSION: &str = "0.4.0";
pub(crate) const ARGENT_CONTRACT_SIERRA: &str = include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/contracts/accounts_artifacts/Argent/argent_0.4.0.sierra"
));
pub const ARGENT_CONTRACT_CLASS_HASH: Felt =
Felt::from_hex_unchecked("0x36078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f");
/// https://github.com/argentlabs/argent-contracts-starknet/blob/main/deployments/multisig.txt
pub const ARGENT_MULTISIG_CONTRACT_VERSION: &str = "0.2.0";
pub(crate) const ARGENT_MULTISIG_CONTRACT_SIERRA: &str = include_str!(concat!(
env!("CARGO_MANIFEST_DIR"),
"/contracts/accounts_artifacts/Argent/argent_multisig_0.2.0.sierra"
));
pub const ARGENT_MULTISIG_CONTRACT_CLASS_HASH: Felt =
Felt::from_hex_unchecked("0x7aeca3456816e3b833506d7cc5c1313d371fbdb0ae95ee70af72a4ddbf42594");
/// https://github.com/OpenZeppelin/cairo-contracts/blob/89a450a88628ec3b86273f261b2d8d1ca9b1522b/src/account/interface.cairo#L7
pub const ISRC6_ID_HEX: &str = "0x2ceccef7f994940b3962a6c67e0ba4fcd37df7d131417c604f91e03caecc1cd";
pub const STARKNET_VERSION: &str = "0.14.1";
pub const DEVNET_DEFAULT_SEED: u32 = 123;
pub const DEVNET_DEFAULT_TEST_SEED: u32 = 123;
pub const DEVNET_DEFAULT_TOTAL_ACCOUNTS: u8 = 10;
pub const DEVNET_DEFAULT_INITIAL_BALANCE: u128 = 1_000_000_000_000_000_000_000;
pub const DEVNET_DEFAULT_L1_GAS_PRICE: NonZeroU128 = nonzero!(1_000_000_000u128);
pub const DEVNET_DEFAULT_L1_DATA_GAS_PRICE: NonZeroU128 = nonzero!(1_000_000_000u128);
pub const DEVNET_DEFAULT_L2_GAS_PRICE: NonZeroU128 = nonzero!(1_000_000_000u128);
pub const DEVNET_DEFAULT_HOST: IpAddr = IpAddr::V4(Ipv4Addr::LOCALHOST);
pub const DEVNET_DEFAULT_PORT: u16 = 5050;
pub const DEVNET_DEFAULT_TIMEOUT: u16 = 120;
pub const DEVNET_DEFAULT_CHAIN_ID: ChainId = ChainId::Testnet;
pub const DEVNET_DEFAULT_STARTING_BLOCK_NUMBER: u64 = 0;
pub const USE_KZG_DA: bool = true;
// chargeable account
pub const CHARGEABLE_ACCOUNT_PUBLIC_KEY: &str =
"0x4C37AB4F0994879337BFD4EAD0800776DB57DA382B8ED8EFAA478C5D3B942A4";
pub const CHARGEABLE_ACCOUNT_PRIVATE_KEY: &str = "0x5FB2959E3011A873A7160F5BB32B0ECE";
pub const CHARGEABLE_ACCOUNT_ADDRESS: &str =
"0x1CAF2DF5ED5DDE1AE3FAEF4ACD72522AC3CB16E23F6DC4C7F9FAED67124C511";
pub fn chargeable_account_initial_balance() -> BigUint {
// Ideally, this would be a constant, but defining it as a string introduces parsing issues and
// making lazy_static a dependency seems too much.
BigUint::from(1_u32) << 255
}
pub const ENTRYPOINT_NOT_FOUND_ERROR_ENCODED: Felt =
Felt::from_hex_unchecked("0x454e545259504f494e545f4e4f545f464f554e44");
pub const MAXIMUM_CONTRACT_CLASS_SIZE: u64 = 4_089_446;
pub const MAXIMUM_CONTRACT_BYTECODE_SIZE: u64 = 81_920;
pub const MAXIMUM_SIERRA_LENGTH: u64 = 81_920;
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/traits.rs | crates/starknet-devnet-core/src/traits.rs | use blockifier::state::state_api::StateReader;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use starknet_types::felt::ClassHash;
use starknet_types::rpc::state::Balance;
use crate::account::FeeToken;
use crate::error::DevnetResult;
use crate::state::state_readers::DictState;
use crate::state::{CustomState, CustomStateReader, StarknetState};
/// This trait should be implemented by structures that internally have collections and each element
/// could be found by a hash
pub trait HashIdentified {
type Element;
type Hash;
fn get_by_hash(&self, hash: Self::Hash) -> Option<&Self::Element>;
}
pub trait HashIdentifiedMut {
type Element;
type Hash;
fn get_by_hash_mut(&mut self, hash: &Self::Hash) -> Option<&mut Self::Element>;
}
pub(crate) trait Deployed {
fn deploy(&self, state: &mut StarknetState) -> DevnetResult<()>;
fn get_address(&self) -> ContractAddress;
/// `class_hash` is sierra hash for cairo1 contracts
fn declare_if_undeclared(
&self,
state: &mut StarknetState,
class_hash: ClassHash,
contract_class: &ContractClass,
) -> DevnetResult<()> {
if !state.is_contract_declared(class_hash) {
state.predeclare_contract_class(class_hash, contract_class.clone())?;
}
Ok(())
}
}
/// This trait sets the interface for the account
pub trait Accounted {
/// Set initial balance for the account in ETH and STRK token
///
/// # Arguments
/// `state` - state of the devnet
fn set_initial_balance(&self, state: &mut DictState) -> DevnetResult<()>;
/// Get balance of the account. In `FeeToken` token
///
/// # Arguments
/// `state` - state of the devnet
/// `token` - enum `FeeToken` to get balance in
#[allow(unused)] // TODO used only in tests?
fn get_balance(&self, state: &mut impl StateReader, token: FeeToken) -> DevnetResult<Balance>;
}
/// This trait should be implemented by structures that generate accounts
pub trait AccountGenerator {
type Acc: Accounted;
fn generate_accounts(
&mut self,
number_of_accounts: u8,
class_hash: ClassHash,
contract_class: &ContractClass,
) -> DevnetResult<&Vec<Self::Acc>>;
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/account.rs | crates/starknet-devnet-core/src/account.rs | use std::sync::Arc;
use blockifier::state::state_api::StateReader;
use starknet_api::core::calculate_contract_address;
use starknet_api::transaction::fields::{Calldata, ContractAddressSalt};
use starknet_api::{felt, patricia_key};
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use starknet_types::error::Error;
use starknet_types::felt::{ClassHash, Key, felt_from_prefixed_hex, join_felts, split_biguint};
use starknet_types::rpc::state::Balance;
use crate::constants::{
CHARGEABLE_ACCOUNT_ADDRESS, CHARGEABLE_ACCOUNT_PRIVATE_KEY, CHARGEABLE_ACCOUNT_PUBLIC_KEY,
ISRC6_ID_HEX, chargeable_account_initial_balance,
};
use crate::contract_class_choice::{AccountClassWrapper, AccountContractClassChoice};
use crate::error::DevnetResult;
use crate::state::state_readers::DictState;
use crate::state::{CustomState, StarknetState};
use crate::traits::{Accounted, Deployed};
use crate::utils::get_storage_var_address;
/// data taken from https://github.com/0xSpaceShard/starknet-devnet-deprecated/blob/fb96e0cc3c1c31fb29892ecefd2a670cf8a32b51/starknet_devnet/account.py
const ACCOUNT_CLASS_HASH_HEX_FOR_ADDRESS_COMPUTATION: &str =
"0x3FCBF77B28C96F4F2FB5BD2D176AB083A12A5E123ADEB0DE955D7EE228C9854";
pub enum FeeToken {
ETH,
STRK,
}
#[derive(Clone)]
pub struct KeyPair {
pub public_key: Key,
pub private_key: Key,
}
#[derive(Clone)]
pub struct Account {
pub keys: KeyPair,
pub account_address: ContractAddress,
pub initial_balance: Balance,
pub class_hash: ClassHash,
pub class_metadata: &'static str,
pub(crate) contract_class: ContractClass,
pub(crate) eth_fee_token_address: ContractAddress,
pub(crate) strk_fee_token_address: ContractAddress,
}
impl Account {
pub(crate) fn new_chargeable(
eth_fee_token_address: ContractAddress,
strk_fee_token_address: ContractAddress,
) -> DevnetResult<Self> {
let AccountClassWrapper { contract_class, class_hash, class_metadata } =
AccountContractClassChoice::Cairo1.get_class_wrapper()?;
Ok(Self {
keys: KeyPair {
public_key: Key::from_hex(CHARGEABLE_ACCOUNT_PUBLIC_KEY)?,
private_key: Key::from_hex(CHARGEABLE_ACCOUNT_PRIVATE_KEY)?,
},
account_address: ContractAddress::new(felt_from_prefixed_hex(
CHARGEABLE_ACCOUNT_ADDRESS,
)?)?,
initial_balance: chargeable_account_initial_balance(),
class_hash,
class_metadata,
contract_class,
eth_fee_token_address,
strk_fee_token_address,
})
}
pub(crate) fn new(
initial_balance: Balance,
keys: KeyPair,
class_hash: ClassHash,
class_metadata: &'static str,
contract_class: ContractClass,
eth_fee_token_address: ContractAddress,
strk_fee_token_address: ContractAddress,
) -> DevnetResult<Self> {
let account_address = Account::compute_account_address(&keys.public_key)?;
Ok(Self {
initial_balance,
keys,
class_hash,
class_metadata,
contract_class,
account_address,
eth_fee_token_address,
strk_fee_token_address,
})
}
fn compute_account_address(public_key: &Key) -> DevnetResult<ContractAddress> {
let account_address = calculate_contract_address(
ContractAddressSalt(felt!(20u32)),
starknet_api::core::ClassHash(felt_from_prefixed_hex(
ACCOUNT_CLASS_HASH_HEX_FOR_ADDRESS_COMPUTATION,
)?),
&Calldata(Arc::new(vec![*public_key])),
starknet_api::core::ContractAddress(patricia_key!(0u32)),
)
.map_err(Error::StarknetApiError)?;
Ok(ContractAddress::from(account_address))
}
// simulate constructor logic (register interfaces and set public key), as done in
// https://github.com/OpenZeppelin/cairo-contracts/blob/89a450a88628ec3b86273f261b2d8d1ca9b1522b/src/account/account.cairo#L207-L211
fn simulate_constructor(&self, state: &mut StarknetState) -> DevnetResult<()> {
let core_address = self.account_address.into();
let interface_storage_var = get_storage_var_address(
"SRC5_supported_interfaces",
&[felt_from_prefixed_hex(ISRC6_ID_HEX)?],
)?;
state.state.state.set_storage_at(core_address, interface_storage_var.into(), Felt::ONE)?;
let public_key_storage_var = get_storage_var_address("Account_public_key", &[])?;
state.state.state.set_storage_at(
core_address,
public_key_storage_var.into(),
self.keys.public_key,
)?;
Ok(())
}
}
impl Deployed for Account {
fn deploy(&self, state: &mut StarknetState) -> DevnetResult<()> {
self.declare_if_undeclared(state, self.class_hash, &self.contract_class)?;
state.predeploy_contract(self.account_address, self.class_hash)?;
self.set_initial_balance(&mut state.state.state)?;
self.simulate_constructor(state)?;
Ok(())
}
fn get_address(&self) -> ContractAddress {
self.account_address
}
}
impl Accounted for Account {
// Set balance directly in the most underlying state
fn set_initial_balance(&self, state: &mut DictState) -> DevnetResult<()> {
let storage_var_address_low: starknet_api::state::StorageKey =
get_storage_var_address("ERC20_balances", &[Felt::from(self.account_address)])?.into();
let storage_var_address_high = storage_var_address_low.next_storage_key()?;
let total_supply_storage_address_low: starknet_api::state::StorageKey =
get_storage_var_address("ERC20_total_supply", &[])?.into();
let total_supply_storage_address_high =
total_supply_storage_address_low.next_storage_key()?;
let (high, low) = split_biguint(self.initial_balance.clone());
for fee_token_address in [self.eth_fee_token_address, self.strk_fee_token_address] {
let token_address = fee_token_address.into();
let total_supply_low =
state.get_storage_at(token_address, total_supply_storage_address_low)?;
let total_supply_high =
state.get_storage_at(token_address, total_supply_storage_address_high)?;
let new_total_supply =
join_felts(&total_supply_high, &total_supply_low) + self.initial_balance.clone();
let (new_total_supply_high, new_total_supply_low) = split_biguint(new_total_supply);
// set balance in ERC20_balances
state.set_storage_at(token_address, storage_var_address_low, low)?;
state.set_storage_at(token_address, storage_var_address_high, high)?;
// set total supply in ERC20_total_supply
state.set_storage_at(
token_address,
total_supply_storage_address_low,
new_total_supply_low,
)?;
state.set_storage_at(
token_address,
total_supply_storage_address_high,
new_total_supply_high,
)?;
}
Ok(())
}
fn get_balance(&self, state: &mut impl StateReader, token: FeeToken) -> DevnetResult<Balance> {
let fee_token_address = match token {
FeeToken::ETH => self.eth_fee_token_address,
FeeToken::STRK => self.strk_fee_token_address,
};
let (low, high) =
state.get_fee_token_balance(self.account_address.into(), fee_token_address.into())?;
Ok(join_felts(&high, &low))
}
}
#[cfg(test)]
mod tests {
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::felt::felt_from_prefixed_hex;
use starknet_types::rpc::state::Balance;
use super::{Account, KeyPair};
use crate::account::FeeToken;
use crate::constants::STRK_ERC20_CONTRACT_CLASS_HASH;
use crate::state::{CustomState, StarknetState};
use crate::traits::{Accounted, Deployed};
use crate::utils::test_utils::{
dummy_cairo_1_contract_class, dummy_contract_address, dummy_felt,
};
/// Testing if generated account address has the same value as the first account in
/// https://github.com/0xSpaceShard/starknet-devnet-deprecated/blob/9d867e38e6d465e568e82a47e82e40608f6d220f/test/support/schemas/predeployed_accounts_fixed_seed.json
#[test]
fn account_address_should_be_equal() {
let expected_result = ContractAddress::new(
felt_from_prefixed_hex(
"0x6e3205f9b7c4328f00f718fdecf56ab31acfb3cd6ffeb999dcbac41236ea502",
)
.unwrap(),
)
.unwrap();
let generated_result = Account::compute_account_address(
&felt_from_prefixed_hex(
"0x60dea6c1228f1db4ca1f9db11c01b6e9cce5e627f7181dcaa27d69cbdbe57b5",
)
.unwrap(),
)
.unwrap();
assert_eq!(expected_result, generated_result);
}
#[test]
fn account_address_should_not_be_equal() {
let expected_result = ContractAddress::new(
felt_from_prefixed_hex(
"0x6e3205f9b7c4328f00f718fdecf56ab31acfb3cd6ffeb999dcbac41236ea502",
)
.unwrap(),
)
.unwrap();
let generated_result = Account::compute_account_address(
&felt_from_prefixed_hex(
"0x60dea6c1228f1db4ca1f9db11c01b6e9cce5e627f7181dcaa27d69cbdbe57b6",
)
.unwrap(),
)
.unwrap();
assert_ne!(expected_result, generated_result);
}
#[test]
fn account_deployed_successfully() {
let (account, mut state) = setup();
assert!(account.deploy(&mut state).is_ok());
}
#[test]
fn account_get_balance_should_return_correct_value() {
let (mut account, mut state) = setup();
let expected_balance = Balance::from(100_u8);
account.initial_balance = expected_balance.clone();
account.deploy(&mut state).unwrap();
let generated_balance = account.get_balance(&mut state, FeeToken::ETH).unwrap();
assert_eq!(expected_balance, generated_balance);
let generated_balance = account.get_balance(&mut state, FeeToken::STRK).unwrap();
assert_eq!(expected_balance, generated_balance);
}
#[test]
fn account_changed_balance_successfully_without_deployment() {
let (account, mut state) = setup();
assert!(account.set_initial_balance(&mut state.state.state).is_ok());
}
#[test]
fn account_get_address_correct() {
let (mut account, _) = setup();
let expected_address = ContractAddress::new(Felt::from(11111)).unwrap();
account.account_address = expected_address;
assert_eq!(expected_address, account.get_address());
}
fn setup() -> (Account, StarknetState) {
let mut state = StarknetState::default();
let fee_token_address = dummy_contract_address();
// deploy the erc20 contract
state.predeploy_contract(fee_token_address, STRK_ERC20_CONTRACT_CLASS_HASH).unwrap();
(
Account::new(
Balance::from(10_u8),
KeyPair { public_key: Felt::from(13431515), private_key: Felt::from(11) },
dummy_felt(),
"Dummy account",
dummy_cairo_1_contract_class().into(),
fee_token_address,
fee_token_address,
)
.unwrap(),
state,
)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/state/state_readers.rs | crates/starknet-devnet-core/src/state/state_readers.rs | use std::collections::HashMap;
use blockifier::execution::contract_class::RunnableCompiledClass;
use blockifier::state::cached_state::StorageEntry;
use blockifier::state::errors::StateError;
use blockifier::state::state_api::{StateReader, StateResult};
use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce};
use starknet_api::state::StorageKey;
use starknet_rs_core::types::Felt;
use crate::starknet::defaulter::StarknetDefaulter;
/// A simple implementation of `StateReader` using `HashMap`s as storage.
/// Copied from blockifier test_utils, added `impl State`
#[derive(Debug, Default, Clone)]
pub struct DictState {
pub storage_view: HashMap<StorageEntry, Felt>,
pub address_to_nonce: HashMap<ContractAddress, Nonce>,
pub address_to_class_hash: HashMap<ContractAddress, ClassHash>,
pub class_hash_to_class: HashMap<ClassHash, RunnableCompiledClass>,
pub class_hash_to_compiled_class_hash: HashMap<ClassHash, CompiledClassHash>,
defaulter: StarknetDefaulter,
}
impl DictState {
pub fn new(defaulter: StarknetDefaulter) -> Self {
Self { defaulter, ..Self::default() }
}
}
impl StateReader for DictState {
fn get_storage_at(
&self,
contract_address: ContractAddress,
key: StorageKey,
) -> StateResult<Felt> {
let contract_storage_key = (contract_address, key);
match self.storage_view.get(&contract_storage_key) {
Some(value) => Ok(*value),
None => self.defaulter.get_storage_at(contract_address, key),
}
}
fn get_nonce_at(&self, contract_address: ContractAddress) -> StateResult<Nonce> {
match self.address_to_nonce.get(&contract_address) {
Some(value) => Ok(*value),
None => self.defaulter.get_nonce_at(contract_address),
}
}
fn get_compiled_class(&self, class_hash: ClassHash) -> StateResult<RunnableCompiledClass> {
match self.class_hash_to_class.get(&class_hash) {
Some(contract_class) => Ok(contract_class.clone()),
None => self.defaulter.get_compiled_class(class_hash),
}
}
fn get_class_hash_at(&self, contract_address: ContractAddress) -> StateResult<ClassHash> {
match self.address_to_class_hash.get(&contract_address) {
Some(class_hash) => Ok(*class_hash),
None => self.defaulter.get_class_hash_at(contract_address),
}
}
fn get_compiled_class_hash(
&self,
class_hash: ClassHash,
) -> StateResult<starknet_api::core::CompiledClassHash> {
// can't ask origin for this - insufficient API - probably not important
// Starknet 0.14.1 update: became important, as it is needed for migration check
let compiled_class_hash =
self.class_hash_to_compiled_class_hash.get(&class_hash).copied().unwrap_or_default();
Ok(compiled_class_hash)
}
fn get_compiled_class_hash_v2(
&self,
class_hash: ClassHash,
_contract_class: &RunnableCompiledClass,
) -> StateResult<CompiledClassHash> {
let compiled_class_hash =
self.class_hash_to_compiled_class_hash.get(&class_hash).copied().unwrap_or_default();
Ok(compiled_class_hash)
}
}
// Basing the methods on blockifier's `State` interface, without those that would never be used
// (add_visited_pcs, to_state_diff)
impl DictState {
pub fn set_storage_at(
&mut self,
contract_address: ContractAddress,
key: StorageKey,
value: Felt,
) -> std::result::Result<(), blockifier::state::errors::StateError> {
self.storage_view.insert((contract_address, key), value);
Ok(())
}
pub fn increment_nonce(&mut self, contract_address: ContractAddress) -> StateResult<()> {
let current_nonce = self.get_nonce_at(contract_address)?;
let next_nonce = Nonce(current_nonce.0 + 1);
self.address_to_nonce.insert(contract_address, next_nonce);
Ok(())
}
pub fn set_class_hash_at(
&mut self,
contract_address: ContractAddress,
class_hash: ClassHash,
) -> StateResult<()> {
if contract_address == ContractAddress::default() {
return Err(StateError::OutOfRangeContractAddress);
}
self.address_to_class_hash.insert(contract_address, class_hash);
Ok(())
}
pub fn set_contract_class(
&mut self,
class_hash: ClassHash,
contract_class: RunnableCompiledClass,
) -> StateResult<()> {
self.class_hash_to_class.insert(class_hash, contract_class);
Ok(())
}
pub fn set_compiled_class_hash(
&mut self,
class_hash: ClassHash,
compiled_class_hash: CompiledClassHash,
) -> StateResult<()> {
self.class_hash_to_compiled_class_hash.insert(class_hash, compiled_class_hash);
Ok(())
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/state/state_diff.rs | crates/starknet-devnet-core/src/state/state_diff.rs | use std::collections::HashMap;
use blockifier::state::cached_state::CachedState;
use blockifier::state::state_api::StateReader;
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use starknet_types::felt::{ClassHash, CompiledClassHash};
use starknet_types::patricia_key::{PatriciaKey, StorageKey};
use starknet_types::rpc::state::{
ClassHashPair, ContractNonce, DeployedContract, ReplacedClasses, StorageDiff, StorageEntry,
ThinStateDiff,
};
use crate::error::DevnetResult;
/// This struct is used to store the difference between state modifications
#[derive(Default, Debug, Clone)]
#[cfg_attr(test, derive(PartialEq, Eq))]
pub struct StateDiff {
pub(crate) storage_updates: HashMap<ContractAddress, HashMap<StorageKey, Felt>>,
pub(crate) address_to_nonce: HashMap<ContractAddress, Felt>,
pub(crate) address_to_class_hash: HashMap<ContractAddress, ClassHash>,
// class hash to compiled_class_hash difference, used when declaring contracts
// that are different from cairo 0
pub(crate) class_hash_to_compiled_class_hash: HashMap<ClassHash, CompiledClassHash>,
// declare contracts that are not cairo 0
pub(crate) declared_contracts: Vec<ClassHash>,
// cairo 0 declared contracts
pub(crate) cairo_0_declared_contracts: Vec<ClassHash>,
// collection of old class hash to new class hash
pub(crate) replaced_classes: Vec<ReplacedClasses>,
}
impl StateDiff {
pub(crate) fn generate<S: StateReader>(
state: &mut CachedState<S>,
new_classes: HashMap<Felt, ContractClass>,
) -> DevnetResult<Self> {
let mut declared_contracts = Vec::<ClassHash>::new();
let mut cairo_0_declared_contracts = Vec::<ClassHash>::new();
let mut replaced_classes = vec![];
let diff = state.to_state_diff()?;
for (class_hash, class) in new_classes {
match class {
ContractClass::Cairo0(_) => cairo_0_declared_contracts.push(class_hash),
ContractClass::Cairo1(_) => declared_contracts.push(class_hash),
}
}
// extract differences of class_hash -> compile_class_hash mapping
let class_hash_to_compiled_class_hash = diff
.state_maps
.compiled_class_hashes
.into_iter()
.map(|(class_hash, compiled_class_hash)| (class_hash.0, compiled_class_hash.0))
.collect();
let address_to_class_hash = diff
.state_maps
.class_hashes
.iter()
.map(|(address, class_hash)| {
let contract_address = ContractAddress::from(*address);
(contract_address, class_hash.0)
})
.collect::<HashMap<ContractAddress, ClassHash>>();
for (contract_address, class_hash) in diff.state_maps.class_hashes {
let old_class_hash = state.state.get_class_hash_at(contract_address)?;
if old_class_hash != class_hash
&& old_class_hash != starknet_api::core::ClassHash::default()
{
replaced_classes.push(ReplacedClasses {
contract_address: contract_address.into(),
class_hash: class_hash.0,
});
}
}
let address_to_nonce = diff
.state_maps
.nonces
.iter()
.map(|(address, nonce)| {
let contract_address = ContractAddress::from(*address);
(contract_address, nonce.0)
})
.collect::<HashMap<ContractAddress, Felt>>();
let mut storage_updates = HashMap::<ContractAddress, HashMap<StorageKey, Felt>>::new();
diff.state_maps.storage.iter().for_each(|((address, key), value)| {
let address_updates = storage_updates.entry((*address).into()).or_default();
address_updates.insert(key.0.into(), *value);
});
Ok(StateDiff {
address_to_class_hash,
address_to_nonce,
storage_updates,
class_hash_to_compiled_class_hash,
cairo_0_declared_contracts,
declared_contracts,
replaced_classes,
})
}
/// Modify this object by extending all of its properties with the corresponding properties of
/// the `other` object.
pub(crate) fn extend(&mut self, other: &StateDiff) {
self.address_to_class_hash.extend(&other.address_to_class_hash);
self.address_to_nonce.extend(&other.address_to_nonce);
self.storage_updates.extend(other.storage_updates.clone());
self.class_hash_to_compiled_class_hash.extend(&other.class_hash_to_compiled_class_hash);
self.cairo_0_declared_contracts.extend(&other.cairo_0_declared_contracts);
self.declared_contracts.extend(&other.declared_contracts);
self.replaced_classes.extend(other.replaced_classes.clone());
}
}
impl From<StateDiff> for ThinStateDiff {
fn from(value: StateDiff) -> Self {
let declared_classes: Vec<(ClassHash, CompiledClassHash)> =
value.class_hash_to_compiled_class_hash.into_iter().collect();
// cairo 0 declarations
let cairo_0_declared_classes: Vec<Felt> = value.cairo_0_declared_contracts;
// storage updates (contract address -> [(storage_entry, value)])
let storage_updates: Vec<(ContractAddress, Vec<(PatriciaKey, Felt)>)> = value
.storage_updates
.into_iter()
.map(|(address, entries)| (address, entries.into_iter().collect()))
.collect();
// contract nonces
let nonces: Vec<(ContractAddress, Felt)> = value.address_to_nonce.into_iter().collect();
// deployed contracts (address -> class hash)
let deployed_contracts: Vec<(ContractAddress, Felt)> =
value.address_to_class_hash.into_iter().collect();
ThinStateDiff {
deployed_contracts: deployed_contracts
.into_iter()
.map(|(address, class_hash)| DeployedContract { address, class_hash })
.collect(),
declared_classes: declared_classes
.into_iter()
.map(|(class_hash, compiled_class_hash)| ClassHashPair {
class_hash,
compiled_class_hash,
})
.collect(),
deprecated_declared_classes: cairo_0_declared_classes,
nonces: nonces
.into_iter()
.map(|(address, nonce)| ContractNonce { contract_address: address, nonce })
.collect(),
storage_diffs: storage_updates
.into_iter()
.map(|(contract_address, updates)| StorageDiff {
address: contract_address,
storage_entries: updates
.into_iter()
.map(|(key, value)| StorageEntry { key, value })
.collect(),
})
.collect(),
replaced_classes: value.replaced_classes,
migrated_compiled_classes: None,
}
}
}
impl From<StateDiff> for starknet_api::state::ThinStateDiff {
fn from(value: StateDiff) -> Self {
let deployed_contracts: Vec<(ContractAddress, Felt)> =
value.address_to_class_hash.into_iter().collect();
let nonces: Vec<(ContractAddress, Felt)> = value.address_to_nonce.into_iter().collect();
starknet_api::state::ThinStateDiff {
deployed_contracts: deployed_contracts
.into_iter()
.map(|(address, class_hash)| {
(
starknet_api::core::ContractAddress::from(address),
starknet_api::core::ClassHash(class_hash),
)
})
.collect(),
storage_diffs: value
.storage_updates
.into_iter()
.map(|(contract_address, updates)| {
(
starknet_api::core::ContractAddress::from(contract_address),
updates
.into_iter()
.map(|(key, value)| (starknet_api::state::StorageKey::from(key), value))
.collect(),
)
})
.collect(),
class_hash_to_compiled_class_hash: value
.class_hash_to_compiled_class_hash
.into_iter()
.map(|(class_hash, compiled_class_hash)| {
(
starknet_api::core::ClassHash(class_hash),
starknet_api::core::CompiledClassHash(compiled_class_hash),
)
})
.collect(),
deprecated_declared_classes: value
.cairo_0_declared_contracts
.iter()
.map(|f| starknet_api::core::ClassHash(*f))
.collect(),
nonces: nonces
.into_iter()
.map(|(address, nonce)| {
(
starknet_api::core::ContractAddress::from(address),
starknet_api::core::Nonce(nonce),
)
})
.collect(),
}
}
}
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use blockifier::state::state_api::{State, StateReader};
use nonzero_ext::nonzero;
use starknet_api::contract_class::compiled_class_hash::{HashVersion, HashableCompiledClass};
use starknet_api::core::ClassHash;
use starknet_rs_core::types::Felt;
use starknet_rs_core::utils::get_selector_from_name;
use starknet_types::compile_sierra_contract;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use starknet_types::rpc::block::{BlockId, BlockTag};
use starknet_types::rpc::state::{Balance, ReplacedClasses};
use starknet_types::rpc::transactions::BroadcastedDeclareTransaction;
use starknet_types::traits::HashProducer;
use super::StateDiff;
use crate::account::Account;
use crate::constants::{ETH_ERC20_CONTRACT_ADDRESS, STRK_ERC20_CONTRACT_ADDRESS};
use crate::starknet::Starknet;
use crate::starknet::starknet_config::StarknetConfig;
use crate::state::{CustomState, StarknetState};
use crate::traits::Deployed;
use crate::utils::test_utils::{
DUMMY_CAIRO_1_COMPILED_CLASS_HASH, broadcasted_declare_tx_v3,
cairo_0_account_without_validations, dummy_cairo_1_contract_class, dummy_contract_address,
dummy_felt, dummy_key_pair, resource_bounds_with_price_1, test_invoke_transaction_v3,
};
#[test]
fn correct_no_difference_between_non_modified_states() {
let mut state = setup();
let block_number = 1;
let new_classes = state.rpc_contract_classes.write().commit(block_number);
let generated_diff = StateDiff::generate(&mut state.state, new_classes).unwrap();
let expected_diff = StateDiff::default();
assert_eq!(generated_diff, expected_diff);
}
#[test]
fn correct_difference_on_cairo1_class_declaration() {
let mut state = setup();
let class_hash = ClassHash(Felt::ONE);
let casm_hash = DUMMY_CAIRO_1_COMPILED_CLASS_HASH;
// necessary to prevent blockifier's state subtraction panic
state.get_compiled_class(class_hash).expect_err("Shouldn't yet be declared");
let contract_class = ContractClass::Cairo1(dummy_cairo_1_contract_class());
state.declare_contract_class(class_hash.0, Some(casm_hash), contract_class).unwrap();
let block_number = 1;
let new_classes = state.rpc_contract_classes.write().commit(block_number);
let generated_diff = StateDiff::generate(&mut state.state, new_classes).unwrap();
let expected_diff = StateDiff {
declared_contracts: vec![class_hash.0],
class_hash_to_compiled_class_hash: HashMap::from([(class_hash.0, casm_hash)]),
..Default::default()
};
assert_eq!(generated_diff, expected_diff);
}
#[test]
fn correct_difference_in_state_diff_object() {
let mut state = setup();
let class_hash = dummy_felt();
let contract_address = dummy_contract_address();
let blockifier_address = contract_address.into();
// necessary to prevent blockifier's state subtraction panic
assert_eq!(state.get_class_hash_at(blockifier_address).unwrap(), ClassHash(Felt::ZERO));
state.state.set_class_hash_at(blockifier_address, ClassHash(class_hash)).unwrap();
let block_number = 1;
let new_classes = state.rpc_contract_classes.write().commit(block_number);
let generated_diff = StateDiff::generate(&mut state.state, new_classes).unwrap();
let expected_diff = StateDiff {
address_to_class_hash: vec![(contract_address, class_hash)].into_iter().collect(),
..StateDiff::default()
};
assert_eq!(generated_diff, expected_diff);
}
#[test]
fn test_class_replacement_produces_correct_state_diff() {
let mut starknet = Starknet::new(&StarknetConfig {
gas_price_wei: nonzero!(1u128),
gas_price_fri: nonzero!(1u128),
data_gas_price_wei: nonzero!(1u128),
data_gas_price_fri: nonzero!(1u128),
l2_gas_price_wei: nonzero!(1u128),
l2_gas_price_fri: nonzero!(1u128),
..Default::default()
})
.unwrap();
let account_without_validations_contract_class = cairo_0_account_without_validations();
let account_without_validations_class_hash =
account_without_validations_contract_class.generate_hash().unwrap();
let account = Account::new(
Balance::from(u128::MAX),
dummy_key_pair(),
account_without_validations_class_hash,
"Custom",
ContractClass::Cairo0(account_without_validations_contract_class),
ContractAddress::new(ETH_ERC20_CONTRACT_ADDRESS).unwrap(),
ContractAddress::new(STRK_ERC20_CONTRACT_ADDRESS).unwrap(),
)
.unwrap();
account.deploy(&mut starknet.pre_confirmed_state).unwrap();
starknet.commit_diff().unwrap();
starknet.generate_new_block_and_state().unwrap();
starknet.restart_pre_confirmed_block().unwrap();
// dummy contract
let replaceable_contract = dummy_cairo_1_contract_class();
let replacing_contract = ContractClass::cairo_1_from_sierra_json_str(
&std::fs::read_to_string(
"../../contracts/test_artifacts/cairo1/events/events_2.0.1_compiler.sierra",
)
.unwrap(),
)
.unwrap();
for (contract_class, nonce) in
[(replaceable_contract.clone(), 0), (replacing_contract.clone(), 1)]
{
let compiled_class_hash =
compile_sierra_contract(&contract_class).unwrap().hash(&HashVersion::V2).0;
starknet
.add_declare_transaction(BroadcastedDeclareTransaction::V3(Box::new(
broadcasted_declare_tx_v3(
account.account_address,
nonce.into(),
contract_class,
compiled_class_hash,
resource_bounds_with_price_1(0, 1000, 1e9 as u64),
),
)))
.unwrap();
}
let replaceable_contract_address = ContractAddress::new(Felt::ONE).unwrap();
let old_class_hash = ContractClass::Cairo1(replaceable_contract).generate_hash().unwrap();
starknet
.pre_confirmed_state
.predeploy_contract(replaceable_contract_address, old_class_hash)
.unwrap();
starknet.commit_diff().unwrap();
starknet.generate_new_block_and_state().unwrap();
starknet.restart_pre_confirmed_block().unwrap();
let new_class_hash = ContractClass::Cairo1(replacing_contract).generate_hash().unwrap();
let invoke_txn = test_invoke_transaction_v3(
account.account_address,
replaceable_contract_address,
get_selector_from_name("test_replace_class").unwrap(),
&[new_class_hash],
2, // nonce
resource_bounds_with_price_1(0, 1000, 1e7 as u64),
);
starknet.add_invoke_transaction(invoke_txn).unwrap();
let state_update = starknet.block_state_update(&BlockId::Tag(BlockTag::Latest)).unwrap();
assert_eq!(
state_update.get_state_diff().replaced_classes,
vec![ReplacedClasses {
contract_address: replaceable_contract_address,
class_hash: new_class_hash
}]
);
}
fn setup() -> StarknetState {
StarknetState::default()
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/state/mod.rs | crates/starknet-devnet-core/src/state/mod.rs | use std::collections::HashMap;
use std::sync::Arc;
use blockifier::state::cached_state::CachedState;
use blockifier::state::state_api::{State, StateReader};
use parking_lot::RwLock;
use starknet_api::contract_class::compiled_class_hash::{HashVersion, HashableCompiledClass};
use starknet_rs_core::types::Felt;
use starknet_types::compile_sierra_contract;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use starknet_types::felt::ClassHash;
use self::state_diff::StateDiff;
use self::state_readers::DictState;
use crate::error::{DevnetResult, Error};
use crate::starknet::defaulter::StarknetDefaulter;
pub(crate) mod state_diff;
pub(crate) mod state_readers;
pub enum BlockNumberOrPreConfirmed {
PreConfirmed,
Number(u64),
}
pub trait CustomStateReader {
fn is_contract_deployed(&self, contract_address: ContractAddress) -> DevnetResult<bool>;
/// using is_contract_deployed with forked state returns that the contract is deployed on the
/// forked side and a validation cannot be skipped when creating a transaction with
/// impersonated account
fn is_contract_deployed_locally(&self, contract_address: ContractAddress)
-> DevnetResult<bool>;
fn is_contract_declared(&self, class_hash: ClassHash) -> bool;
}
pub trait CustomState {
/// Link class with its hash; if cairo1 class: calculate casm hash, link class hash with it
fn predeclare_contract_class(
&mut self,
class_hash: ClassHash,
contract_class: ContractClass,
) -> DevnetResult<()>;
/// Link class with its hash; if cairo1 class: link class hash with casm hash
fn declare_contract_class(
&mut self,
class_hash: ClassHash,
casm_hash: Option<starknet_types::felt::CompiledClassHash>,
contract_class: ContractClass,
) -> DevnetResult<()>;
/// Link contract address to class hash. Does not include balance modification or constructor
/// simulation.
fn predeploy_contract(
&mut self,
contract_address: ContractAddress,
class_hash: ClassHash,
) -> DevnetResult<()>;
}
#[derive(Default, Clone)]
/// Utility structure that makes it easier to calculate state diff later on. Classes are first
/// inserted into the staging area (pre_confirmed state), later to be committed (assigned a block
/// number to mark when they were added). Committed doesn't necessarily mean the class is a part of
/// the latest state, just that it is bound to be. Since there is no way of telling if a class is in
/// the latest state or no, retrieving from the latest state has to be done via block number.
pub struct CommittedClassStorage {
staging: HashMap<ClassHash, ContractClass>,
committed: HashMap<ClassHash, (ContractClass, u64)>,
/// Remembers all classes committed at a block
block_number_to_classes: HashMap<u64, Vec<ClassHash>>,
}
impl CommittedClassStorage {
/// Insert a new class into the staging area. Once it can be committed, call `commit`.
pub fn insert(&mut self, class_hash: ClassHash, contract_class: ContractClass) {
self.staging.insert(class_hash, contract_class);
}
/// Commits all of the staged classes and returns them, together with their hashes.
pub fn commit(&mut self, block_number: u64) -> HashMap<ClassHash, ContractClass> {
let mut newly_committed = HashMap::new();
let hashes_at_this_block = self.block_number_to_classes.entry(block_number).or_default();
for (class_hash, class) in &self.staging {
newly_committed.insert(*class_hash, class.clone());
self.committed.insert(*class_hash, (class.clone(), block_number));
hashes_at_this_block.push(*class_hash);
}
self.empty_staging();
newly_committed
}
/// Returns sierra for cairo1; returns the only artifact for cairo0.
pub fn get_class(
&self,
class_hash: &ClassHash,
block_number_or_pre_confirmed: &BlockNumberOrPreConfirmed,
) -> Option<ContractClass> {
if let Some((class, storage_block_number)) = self.committed.get(class_hash) {
// If we're here, the requested class was committed at some point, need to see when.
match block_number_or_pre_confirmed {
BlockNumberOrPreConfirmed::Number(query_block_number) => {
// If the class was stored before the block at which we are querying (or at that
// block), we can return it.
if storage_block_number <= query_block_number {
Some(class.clone())
} else {
None
}
}
BlockNumberOrPreConfirmed::PreConfirmed => {
// Class is requested at block_id=pre_confirmed. Since it's present among the
// committed classes, it's in the latest block or older and can be returned.
Some(class.clone())
}
}
} else if let Some(class) = self.staging.get(class_hash) {
// If class present in storage.staging, it can only be retrieved if
// block_id=pre_confirmed
match block_number_or_pre_confirmed {
BlockNumberOrPreConfirmed::PreConfirmed => Some(class.clone()),
_ => None,
}
} else {
None
}
}
/// Removes all classes committed at `block_number`. If no classes were committed at that block,
/// does nothing.
pub fn remove_classes_at(&mut self, block_number: u64) {
if let Some(removable) = self.block_number_to_classes.remove(&block_number) {
for class_hash in removable {
self.committed.remove(&class_hash);
}
}
}
/// Removes all staged classes.
pub fn empty_staging(&mut self) {
self.staging = Default::default();
}
}
pub struct StarknetState {
pub(crate) state: CachedState<DictState>,
/// The class storage is meant to be shared between states to prevent copying (due to memory
/// concerns). Knowing which class was added when is made possible by storing the class
/// together with the block number.
rpc_contract_classes: Arc<RwLock<CommittedClassStorage>>,
/// Used for old state preservation purposes.
historic_state: DictState,
}
impl Default for StarknetState {
fn default() -> Self {
Self {
state: CachedState::new(Default::default()),
rpc_contract_classes: Default::default(),
historic_state: Default::default(),
}
}
}
impl StarknetState {
pub fn new(
defaulter: StarknetDefaulter,
rpc_contract_classes: Arc<RwLock<CommittedClassStorage>>,
) -> Self {
Self {
state: CachedState::new(DictState::new(defaulter)),
rpc_contract_classes,
historic_state: Default::default(),
}
}
pub fn clone_rpc_contract_classes(&self) -> CommittedClassStorage {
self.rpc_contract_classes.read().clone()
}
/// Commits and returns the state difference accumulated since the previous (historic) state.
pub(crate) fn commit_diff(&mut self, block_number: u64) -> DevnetResult<StateDiff> {
let new_classes = self.rpc_contract_classes.write().commit(block_number);
let diff = StateDiff::generate(&mut self.state, new_classes)?;
let new_historic = self.expand_historic(diff.clone())?;
self.state = CachedState::new(new_historic.clone());
Ok(diff)
}
pub fn assert_contract_deployed(&self, contract_address: ContractAddress) -> DevnetResult<()> {
if !self.is_contract_deployed(contract_address)? {
return Err(Error::ContractNotFound);
}
Ok(())
}
/// Expands the internal historic state copy and returns a reference to it
fn expand_historic(&mut self, state_diff: StateDiff) -> DevnetResult<&DictState> {
let mut historic_state = self.state.state.clone();
for (address, class_hash) in state_diff.address_to_class_hash {
historic_state
.set_class_hash_at(address.into(), starknet_api::core::ClassHash(class_hash))?;
}
for (class_hash, casm_hash) in state_diff.class_hash_to_compiled_class_hash {
historic_state.set_compiled_class_hash(
starknet_api::core::ClassHash(class_hash),
starknet_api::core::CompiledClassHash(casm_hash),
)?;
}
for (address, _nonce) in state_diff.address_to_nonce {
// assuming that historic_state.get_nonce(address) == _nonce - 1
historic_state.increment_nonce(address.into())?;
}
for (address, storage_updates) in state_diff.storage_updates {
let core_address = address.into();
for (key, value) in storage_updates {
historic_state.set_storage_at(core_address, key.into(), value)?;
}
}
for class_hash in state_diff.cairo_0_declared_contracts {
let class_hash = starknet_api::core::ClassHash(class_hash);
let compiled_class = self.get_compiled_class(class_hash)?;
historic_state.set_contract_class(class_hash, compiled_class)?;
}
for class_hash in state_diff.declared_contracts {
let class_hash = starknet_api::core::ClassHash(class_hash);
let compiled_class = self.get_compiled_class(class_hash)?;
historic_state.set_contract_class(class_hash, compiled_class)?;
}
self.historic_state = historic_state;
Ok(&self.historic_state)
}
pub fn clone_historic(&self) -> Self {
Self {
state: CachedState::new(self.historic_state.clone()),
rpc_contract_classes: self.rpc_contract_classes.clone(),
historic_state: self.historic_state.clone(),
}
}
}
impl State for StarknetState {
fn set_storage_at(
&mut self,
contract_address: starknet_api::core::ContractAddress,
key: starknet_api::state::StorageKey,
value: Felt,
) -> std::result::Result<(), blockifier::state::errors::StateError> {
self.state.set_storage_at(contract_address, key, value)
}
fn increment_nonce(
&mut self,
contract_address: starknet_api::core::ContractAddress,
) -> blockifier::state::state_api::StateResult<()> {
self.state.increment_nonce(contract_address)
}
fn set_class_hash_at(
&mut self,
contract_address: starknet_api::core::ContractAddress,
class_hash: starknet_api::core::ClassHash,
) -> blockifier::state::state_api::StateResult<()> {
self.state.set_class_hash_at(contract_address, class_hash)
}
fn set_contract_class(
&mut self,
class_hash: starknet_api::core::ClassHash,
contract_class: blockifier::execution::contract_class::RunnableCompiledClass,
) -> blockifier::state::state_api::StateResult<()> {
self.state.set_contract_class(class_hash, contract_class)
}
fn set_compiled_class_hash(
&mut self,
class_hash: starknet_api::core::ClassHash,
compiled_class_hash: starknet_api::core::CompiledClassHash,
) -> blockifier::state::state_api::StateResult<()> {
self.state.set_compiled_class_hash(class_hash, compiled_class_hash)
}
}
impl blockifier::state::state_api::StateReader for StarknetState {
fn get_storage_at(
&self,
contract_address: starknet_api::core::ContractAddress,
key: starknet_api::state::StorageKey,
) -> blockifier::state::state_api::StateResult<Felt> {
self.state.get_storage_at(contract_address, key)
}
fn get_nonce_at(
&self,
contract_address: starknet_api::core::ContractAddress,
) -> blockifier::state::state_api::StateResult<starknet_api::core::Nonce> {
self.state.get_nonce_at(contract_address)
}
fn get_class_hash_at(
&self,
contract_address: starknet_api::core::ContractAddress,
) -> blockifier::state::state_api::StateResult<starknet_api::core::ClassHash> {
self.state.get_class_hash_at(contract_address)
}
fn get_compiled_class(
&self,
class_hash: starknet_api::core::ClassHash,
) -> blockifier::state::state_api::StateResult<
blockifier::execution::contract_class::RunnableCompiledClass,
> {
self.state.get_compiled_class(class_hash)
}
fn get_compiled_class_hash(
&self,
class_hash: starknet_api::core::ClassHash,
) -> blockifier::state::state_api::StateResult<starknet_api::core::CompiledClassHash> {
self.state.get_compiled_class_hash(class_hash)
}
fn get_compiled_class_hash_v2(
&self,
class_hash: starknet_api::core::ClassHash,
compiled_class: &blockifier::execution::contract_class::RunnableCompiledClass,
) -> blockifier::state::state_api::StateResult<starknet_api::core::CompiledClassHash> {
self.state.get_compiled_class_hash_v2(class_hash, compiled_class)
}
}
impl CustomStateReader for StarknetState {
fn is_contract_deployed(&self, contract_address: ContractAddress) -> DevnetResult<bool> {
let api_address = contract_address.into();
let starknet_api::core::ClassHash(class_hash) = self.get_class_hash_at(api_address)?;
Ok(class_hash != Felt::ZERO)
}
fn is_contract_declared(&self, class_hash: ClassHash) -> bool {
// get_compiled_class is important if forking; checking hash is impossible via JSON-RPC
let class_hash = starknet_api::core::ClassHash(class_hash);
self.get_compiled_class_hash(class_hash)
.is_ok_and(|starknet_api::core::CompiledClassHash(class_hash)| class_hash != Felt::ZERO)
|| self.get_compiled_class(class_hash).is_ok()
}
fn is_contract_deployed_locally(
&self,
contract_address: ContractAddress,
) -> DevnetResult<bool> {
let api_address = contract_address.into();
Ok(self.state.state.address_to_class_hash.contains_key(&api_address))
}
}
impl CustomState for StarknetState {
/// writes directly to the most underlying state, skipping cache
fn predeclare_contract_class(
&mut self,
class_hash: ClassHash,
contract_class: ContractClass,
) -> DevnetResult<()> {
let compiled_class = contract_class.clone().try_into()?;
let class_hash = starknet_api::core::ClassHash(class_hash);
if let ContractClass::Cairo1(cairo_lang_contract_class) = &contract_class {
let casm_hash =
compile_sierra_contract(cairo_lang_contract_class)?.hash(&HashVersion::V2).0;
self.state.state.set_compiled_class_hash(
class_hash,
starknet_api::core::CompiledClassHash(casm_hash),
)?;
};
self.state.state.set_contract_class(class_hash, compiled_class)?;
let mut class_storage = self.rpc_contract_classes.write();
class_storage.insert(*class_hash, contract_class);
Ok(())
}
fn declare_contract_class(
&mut self,
class_hash: ClassHash,
casm_hash: Option<starknet_types::felt::CompiledClassHash>,
contract_class: ContractClass,
) -> DevnetResult<()> {
let compiled_class = contract_class.clone().try_into()?;
let class_hash = starknet_api::core::ClassHash(class_hash);
if let Some(casm_hash) = casm_hash {
self.set_compiled_class_hash(
class_hash,
starknet_api::core::CompiledClassHash(casm_hash),
)?;
};
self.set_contract_class(class_hash, compiled_class)?;
let mut class_storage = self.rpc_contract_classes.write();
class_storage.insert(*class_hash, contract_class);
Ok(())
}
fn predeploy_contract(
&mut self,
contract_address: ContractAddress,
class_hash: ClassHash,
) -> DevnetResult<()> {
let converted_contract_address = contract_address.into();
self.state.state.set_class_hash_at(
converted_contract_address,
starknet_api::core::ClassHash(class_hash),
)?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use blockifier::state::errors::StateError;
use blockifier::state::state_api::{State, StateReader};
use starknet_api::core::Nonce;
use starknet_api::state::StorageKey;
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use super::StarknetState;
use crate::state::{BlockNumberOrPreConfirmed, CustomState, CustomStateReader};
use crate::utils::test_utils::{
DUMMY_CAIRO_1_COMPILED_CLASS_HASH, dummy_cairo_1_contract_class, dummy_contract_address,
dummy_felt,
};
pub(crate) fn dummy_contract_storage_key() -> (starknet_api::core::ContractAddress, StorageKey)
{
(0xfe_u128.into(), 0xdd10_u128.into())
}
#[test]
fn test_class_present_after_declaration() {
let mut state = StarknetState::default();
let class_hash = dummy_felt();
let casm_hash = Some(dummy_felt());
let contract_class = ContractClass::Cairo1(dummy_cairo_1_contract_class());
state.declare_contract_class(class_hash, casm_hash, contract_class).unwrap();
assert!(state.is_contract_declared(dummy_felt()));
}
#[test]
fn apply_state_updates_for_storage_successfully() {
let mut state = StarknetState::default();
let (contract_address, storage_key) = dummy_contract_storage_key();
let storage_before = state.get_storage_at(contract_address, storage_key).unwrap();
assert_eq!(storage_before, Felt::ZERO);
state.set_storage_at(contract_address, storage_key, dummy_felt()).unwrap();
let storage_after = state.get_storage_at(contract_address, storage_key).unwrap();
assert_eq!(storage_after, dummy_felt());
}
#[test]
fn apply_state_updates_for_address_nonce_successfully() {
let mut state = StarknetState::default();
state.predeploy_contract(dummy_contract_address(), dummy_felt()).unwrap();
let contract_address = dummy_contract_address().into();
// should be zero before update
assert_eq!(state.get_nonce_at(contract_address).unwrap(), Nonce(Felt::ZERO));
state.state.increment_nonce(contract_address).unwrap();
state.commit_diff(1).unwrap();
// check if nonce update was correct
assert_eq!(state.get_nonce_at(contract_address).unwrap(), Nonce(Felt::ONE));
}
#[test]
fn declare_cairo_1_contract_class_successfully() {
let mut state = StarknetState::default();
let class_hash = starknet_api::core::ClassHash(Felt::from_hex_unchecked("0xFE"));
let casm_hash = Some(dummy_felt());
match state.get_compiled_class(class_hash) {
Err(StateError::UndeclaredClassHash(reported_hash)) => {
assert_eq!(reported_hash, class_hash);
}
other => panic!("Invalid result: {other:?}"),
}
let contract_class = dummy_cairo_1_contract_class();
state
.declare_contract_class(class_hash.0, casm_hash, contract_class.clone().into())
.unwrap();
let block_number = 1;
state.commit_diff(block_number).unwrap();
match state.get_compiled_class(class_hash) {
Ok(retrieved_class) => assert_eq!(
retrieved_class,
ContractClass::Cairo1(contract_class.clone()).try_into().unwrap()
),
other => panic!("Invalid result: {other:?}"),
}
let retrieved_rpc_class = state
.rpc_contract_classes
.read()
.get_class(&class_hash, &BlockNumberOrPreConfirmed::Number(block_number))
.unwrap();
assert_eq!(retrieved_rpc_class, contract_class.into());
}
#[test]
fn deploy_cairo_1_contract_class_successfully() {
let (mut state, address) = setup();
let felt = dummy_felt();
state.predeploy_contract(address, felt).unwrap();
let core_address = address.into();
assert_eq!(state.get_nonce_at(core_address).unwrap(), Nonce(Felt::ZERO));
}
#[test]
fn change_storage_successfully() {
let mut state = StarknetState::default();
let (contract_address, storage_key) = dummy_contract_storage_key();
let storage_value = dummy_felt();
state.set_storage_at(contract_address, storage_key, storage_value).unwrap();
assert_eq!(state.get_storage_at(contract_address, storage_key).unwrap(), storage_value);
}
#[test]
fn increment_nonce_successful() {
let (mut state, address) = setup();
let core_address = address.into();
state.increment_nonce(core_address).unwrap();
let nonce = *state.get_nonce_at(core_address).unwrap();
assert_eq!(nonce, Felt::ONE)
}
#[test]
fn read_from_storage_returns_correct_result() {
let (mut state, _) = setup();
let expected_result = Felt::from(33_u32);
let (contract_address, storage_key) = dummy_contract_storage_key();
let class_hash = dummy_felt();
state.predeploy_contract(contract_address.into(), class_hash).unwrap();
state.set_storage_at(contract_address, storage_key, expected_result).unwrap();
let generated_result = state.get_storage_at(contract_address, storage_key).unwrap();
assert_eq!(expected_result, generated_result);
}
#[test]
fn get_nonce_should_return_zero_when_contract_not_deployed() {
let (state, _) = setup();
let dummy_address = starknet_api::core::ContractAddress::from(1_u32);
match state.get_nonce_at(dummy_address) {
Ok(Nonce(n)) => assert_eq!(n, Felt::ZERO),
other => panic!("Invalid nonce: {other:?}"),
}
}
#[test]
fn get_nonce_should_return_zero_for_freshly_deployed_contract() {
let (state, address) = setup();
let core_address = address.into();
assert_eq!(state.get_nonce_at(core_address).unwrap(), Nonce(Felt::ZERO));
}
fn setup() -> (StarknetState, ContractAddress) {
let mut state = StarknetState::default();
let address = dummy_contract_address();
let contract_class = dummy_cairo_1_contract_class();
let class_hash = dummy_felt();
let casm_hash = Some(DUMMY_CAIRO_1_COMPILED_CLASS_HASH);
state.declare_contract_class(class_hash, casm_hash, contract_class.into()).unwrap();
state.predeploy_contract(address, class_hash).unwrap();
(state, address)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/blocks/mod.rs | crates/starknet-devnet-core/src/blocks/mod.rs | use std::collections::HashMap;
use indexmap::IndexMap;
use starknet_api::block::{BlockHeader, BlockHeaderWithoutHash, BlockNumber, BlockTimestamp};
use starknet_api::block_hash::block_hash_calculator::BlockHeaderCommitments;
use starknet_api::data_availability::L1DataAvailabilityMode;
use starknet_api::felt;
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::felt::{BlockHash, TransactionHash};
use starknet_types::rpc::block::{BlockId, BlockStatus, BlockTag, ResourcePrice};
use starknet_types::traits::HashProducer;
use starknet_types_core::hash::{Poseidon, StarkHash};
use crate::constants::{DEVNET_DEFAULT_STARTING_BLOCK_NUMBER, STARKNET_VERSION};
use crate::error::{DevnetResult, Error};
use crate::state::StarknetState;
use crate::state::state_diff::StateDiff;
use crate::traits::HashIdentified;
pub(crate) struct StarknetBlocks {
pub(crate) num_to_hash: IndexMap<BlockNumber, BlockHash>,
pub(crate) hash_to_block: HashMap<BlockHash, StarknetBlock>,
pub(crate) pre_confirmed_block: StarknetBlock,
pub(crate) last_block_hash: Option<BlockHash>,
pub(crate) hash_to_state_diff: HashMap<BlockHash, StateDiff>,
pub(crate) hash_to_state: HashMap<BlockHash, StarknetState>,
pub(crate) aborted_blocks: Vec<Felt>,
pub(crate) starting_block_number: u64,
pub(crate) last_accepted_on_l1: Option<BlockHash>,
}
impl HashIdentified for StarknetBlocks {
type Element = StarknetBlock;
type Hash = BlockHash;
fn get_by_hash(&self, hash: Self::Hash) -> Option<&Self::Element> {
let block = self.hash_to_block.get(&hash)?;
Some(block)
}
}
impl Default for StarknetBlocks {
fn default() -> Self {
Self {
num_to_hash: IndexMap::new(),
hash_to_block: HashMap::new(),
pre_confirmed_block: StarknetBlock::create_pre_confirmed_block(),
last_block_hash: None,
hash_to_state_diff: HashMap::new(),
hash_to_state: HashMap::new(),
aborted_blocks: Vec::new(),
starting_block_number: DEVNET_DEFAULT_STARTING_BLOCK_NUMBER,
last_accepted_on_l1: None,
}
}
}
impl StarknetBlocks {
pub fn new(starting_block_number: u64, last_block_hash: Option<Felt>) -> Self {
let mut blocks = Self { starting_block_number, ..Default::default() };
blocks.pre_confirmed_block.set_block_number(starting_block_number);
blocks.last_block_hash = last_block_hash;
blocks
}
/// Inserts a block in the collection and modifies the block parent hash to match the last block
/// hash
pub fn insert(&mut self, mut block: StarknetBlock, state_diff: StateDiff) {
if let Some(last_block_hash) = self.last_block_hash {
block.header.block_header_without_hash.parent_hash =
starknet_api::block::BlockHash(last_block_hash);
}
let hash = block.block_hash();
let block_number = block.block_number();
self.num_to_hash.insert(block_number, hash);
self.hash_to_block.insert(hash, block);
self.hash_to_state_diff.insert(hash, state_diff);
self.last_block_hash = Some(hash);
}
fn get_by_num(&self, num: &BlockNumber) -> Option<&StarknetBlock> {
let block_hash = self.num_to_hash.get(num)?;
let block = self.hash_to_block.get(block_hash)?;
Some(block)
}
pub fn save_state_at(&mut self, block_hash: Felt, state: StarknetState) {
self.hash_to_state.insert(block_hash, state);
}
fn get_by_latest_hash(&self) -> Option<&StarknetBlock> {
if let Some(hash) = self.last_block_hash { self.get_by_hash(hash) } else { None }
}
pub fn get_by_block_id(&self, block_id: &BlockId) -> Option<&StarknetBlock> {
match block_id {
BlockId::Hash(hash) => self.get_by_hash(*hash),
BlockId::Number(block_number) => self.get_by_num(&BlockNumber(*block_number)),
BlockId::Tag(BlockTag::PreConfirmed) => Some(&self.pre_confirmed_block),
BlockId::Tag(BlockTag::Latest) => self.get_by_latest_hash(),
BlockId::Tag(BlockTag::L1Accepted) => {
self.last_accepted_on_l1.and_then(|h| self.get_by_hash(h))
}
}
}
/// Returns the block number from a block id, by finding the block by the block id
fn block_number_from_block_id(&self, block_id: &BlockId) -> Option<BlockNumber> {
self.get_by_block_id(block_id).map(|block| block.block_number())
}
/// Filter blocks based on from and to block ids and returns a collection of block's references
/// in ascending order
///
/// # Arguments
/// * `from` - The block id from which to start the filtering
/// * `to` - The block id to which to end the filtering
pub fn get_blocks(
&self,
from: Option<BlockId>,
to: Option<BlockId>,
) -> DevnetResult<Vec<&StarknetBlock>> {
// used IndexMap to keep elements in the order of the keys
let mut filtered_blocks: IndexMap<Felt, &StarknetBlock> = IndexMap::new();
let pre_confirmed_block_number = self.pre_confirmed_block.block_number();
let starting_block = if let Some(block_id) = from {
// If the value for block number provided is not correct it will return None
// So we have to return an error
let block_number = self.block_number_from_block_id(&block_id).ok_or(Error::NoBlock)?;
Some(block_number)
} else {
None
};
let ending_block = if let Some(block_id) = to {
// if the value for block number provided is not correct it will return None
// So we set the block number to the first possible block number which is 0
let block_number = self.block_number_from_block_id(&block_id).ok_or(Error::NoBlock)?;
Some(block_number)
} else {
None
};
fn is_block_number_in_range(
current_block_number: BlockNumber,
starting_block: Option<BlockNumber>,
ending_block: Option<BlockNumber>,
) -> bool {
match (starting_block, ending_block) {
(None, None) => true,
(Some(start), None) => current_block_number >= start,
(None, Some(end)) => current_block_number <= end,
(Some(start), Some(end)) => {
current_block_number >= start && current_block_number <= end
}
}
}
let mut insert_pre_confirmed_block_in_final_result = true;
// iterate over the blocks and apply the filter
// then insert the filtered blocks into the index map
self.num_to_hash
.iter()
.filter(|(current_block_number, _)| {
is_block_number_in_range(**current_block_number, starting_block, ending_block)
})
.for_each(|(block_number, block_hash)| {
if *block_number == pre_confirmed_block_number {
insert_pre_confirmed_block_in_final_result = false;
}
filtered_blocks.insert(*block_hash, &self.hash_to_block[block_hash]);
});
let mut result: Vec<&StarknetBlock> = filtered_blocks.into_values().collect();
if is_block_number_in_range(pre_confirmed_block_number, starting_block, ending_block)
&& insert_pre_confirmed_block_in_final_result
{
result.push(&self.pre_confirmed_block);
}
Ok(result)
}
pub(crate) fn remove(&mut self, block_hash: &BlockHash) -> Option<StarknetBlock> {
// Use question marks to early-return None.
self.hash_to_state.remove(block_hash)?;
self.hash_to_state_diff.remove(block_hash)?;
let block = self.hash_to_block.remove(block_hash)?;
self.num_to_hash.shift_remove(&block.block_number())?;
Some(block)
}
pub fn next_latest_block_number(&self) -> BlockNumber {
BlockNumber(self.pre_confirmed_block.block_number().0)
}
}
#[derive(Clone)]
#[cfg_attr(test, derive(PartialEq, Eq))]
pub struct StarknetBlock {
pub(crate) header: BlockHeader,
transaction_hashes: Vec<TransactionHash>,
pub(crate) status: BlockStatus,
}
impl From<&StarknetBlock> for starknet_types::rpc::block::PreConfirmedBlockHeader {
fn from(value: &StarknetBlock) -> Self {
Self {
block_number: value.block_number(),
sequencer_address: value.sequencer_address(),
timestamp: value.timestamp(),
starknet_version: STARKNET_VERSION.to_string(),
l1_gas_price: ResourcePrice {
price_in_fri: value
.header
.block_header_without_hash
.l1_gas_price
.price_in_fri
.0
.into(),
price_in_wei: value
.header
.block_header_without_hash
.l1_gas_price
.price_in_wei
.0
.into(),
},
l1_data_gas_price: ResourcePrice {
price_in_fri: value
.header
.block_header_without_hash
.l1_data_gas_price
.price_in_fri
.0
.into(),
price_in_wei: value
.header
.block_header_without_hash
.l1_data_gas_price
.price_in_wei
.0
.into(),
},
l1_da_mode: value.header.block_header_without_hash.l1_da_mode,
l2_gas_price: ResourcePrice {
price_in_fri: value
.header
.block_header_without_hash
.l2_gas_price
.price_in_fri
.0
.into(),
price_in_wei: value
.header
.block_header_without_hash
.l2_gas_price
.price_in_wei
.0
.into(),
},
}
}
}
impl From<&StarknetBlock> for starknet_types::rpc::block::BlockHeader {
fn from(value: &StarknetBlock) -> Self {
Self {
block_hash: value.block_hash(),
parent_hash: value.parent_hash(),
block_number: value.block_number(),
sequencer_address: value.sequencer_address(),
new_root: value.new_root(),
timestamp: value.timestamp(),
starknet_version: STARKNET_VERSION.to_string(),
l1_gas_price: ResourcePrice {
price_in_fri: value
.header
.block_header_without_hash
.l1_gas_price
.price_in_fri
.0
.into(),
price_in_wei: value
.header
.block_header_without_hash
.l1_gas_price
.price_in_wei
.0
.into(),
},
l1_data_gas_price: ResourcePrice {
price_in_fri: value
.header
.block_header_without_hash
.l1_data_gas_price
.price_in_fri
.0
.into(),
price_in_wei: value
.header
.block_header_without_hash
.l1_data_gas_price
.price_in_wei
.0
.into(),
},
l1_da_mode: value.header.block_header_without_hash.l1_da_mode,
l2_gas_price: ResourcePrice {
price_in_fri: value
.header
.block_header_without_hash
.l2_gas_price
.price_in_fri
.0
.into(),
price_in_wei: value
.header
.block_header_without_hash
.l2_gas_price
.price_in_wei
.0
.into(),
},
n_transactions: value.header.n_transactions as u64,
n_events: value.header.n_events as u64,
state_diff_length: value.header.state_diff_length.unwrap_or(0) as u64,
state_diff_commitment: value.header.state_diff_commitment.unwrap_or_default(),
transaction_commitment: value.header.transaction_commitment.unwrap_or_default(),
event_commitment: value.header.event_commitment.unwrap_or_default(),
receipt_commitment: value.header.receipt_commitment.unwrap_or_default(),
}
}
}
impl StarknetBlock {
pub(crate) fn add_transaction(&mut self, transaction_hash: TransactionHash) {
self.transaction_hashes.push(transaction_hash);
}
pub fn get_transactions(&self) -> &Vec<TransactionHash> {
&self.transaction_hashes
}
pub fn status(&self) -> &BlockStatus {
&self.status
}
pub fn block_hash(&self) -> BlockHash {
self.header.block_hash.0
}
pub fn parent_hash(&self) -> BlockHash {
self.header.block_header_without_hash.parent_hash.0
}
pub fn sequencer_address(&self) -> ContractAddress {
self.header.block_header_without_hash.sequencer.0.into()
}
pub fn timestamp(&self) -> BlockTimestamp {
self.header.block_header_without_hash.timestamp
}
pub fn new_root(&self) -> Felt {
self.header.block_header_without_hash.state_root.0
}
pub(crate) fn set_block_hash(&mut self, block_hash: BlockHash) {
self.header.block_hash = starknet_api::block::BlockHash(block_hash);
}
pub fn block_number(&self) -> BlockNumber {
self.header.block_header_without_hash.block_number
}
pub(crate) fn create_pre_confirmed_block() -> Self {
Self {
header: BlockHeader {
block_header_without_hash: BlockHeaderWithoutHash {
l1_da_mode: L1DataAvailabilityMode::Blob,
..Default::default()
},
..BlockHeader::default()
},
status: BlockStatus::PreConfirmed,
transaction_hashes: Vec::new(),
}
}
pub fn create_empty_accepted() -> Self {
Self {
header: BlockHeader::default(),
transaction_hashes: vec![],
status: BlockStatus::AcceptedOnL2,
}
}
pub(crate) fn set_block_number(&mut self, block_number: u64) {
self.header.block_header_without_hash.block_number = BlockNumber(block_number)
}
pub(crate) fn set_timestamp(&mut self, timestamp: BlockTimestamp) {
self.header.block_header_without_hash.timestamp = timestamp;
}
pub(crate) fn set_counts(
&mut self,
n_transactions: usize,
n_events: usize,
state_diff_length: usize,
) {
self.header.n_transactions = n_transactions;
self.header.n_events = n_events;
self.header.state_diff_length = Some(state_diff_length);
}
pub(crate) fn set_commitments(&mut self, commitments: BlockHeaderCommitments) {
self.header.transaction_commitment = Some(commitments.transaction_commitment);
self.header.event_commitment = Some(commitments.event_commitment);
self.header.receipt_commitment = Some(commitments.receipt_commitment);
self.header.state_diff_commitment = Some(commitments.state_diff_commitment);
}
}
impl HashProducer for StarknetBlock {
type Error = Error;
fn generate_hash(&self) -> DevnetResult<BlockHash> {
let hash = Poseidon::hash_array(&[
felt!(self.header.block_header_without_hash.block_number.0), // block number
self.header.block_header_without_hash.state_root.0, // global_state_root
*self.header.block_header_without_hash.sequencer.0.key(), // sequencer_address
Felt::ZERO, /* block_timestamp;
* would normally be
* felt!(self.header.
* timestamp.0), but
* is modified to enable replicability
* in re-execution on
* loading on dump */
felt!(self.transaction_hashes.len() as u64), // transaction_count
Felt::ZERO, // transaction_commitment
Felt::ZERO, // event_count
Felt::ZERO, // event_commitment
Felt::ZERO, // protocol_version
Felt::ZERO, // extra_data
self.header.block_header_without_hash.parent_hash.0, // parent_block_hash
]);
Ok(hash)
}
}
#[cfg(test)]
mod tests {
use starknet_api::block::{BlockHash, BlockHeader, BlockHeaderWithoutHash, BlockNumber};
use starknet_api::data_availability::L1DataAvailabilityMode;
use starknet_rs_core::types::Felt;
use starknet_types::rpc::block::{BlockId, BlockStatus, BlockTag};
use starknet_types::traits::HashProducer;
use super::{StarknetBlock, StarknetBlocks};
use crate::state::state_diff::StateDiff;
use crate::traits::HashIdentified;
#[test]
fn get_blocks_return_in_correct_order() {
let mut blocks = StarknetBlocks::default();
for block_number in 1..=10 {
let mut block_to_insert = StarknetBlock::create_pre_confirmed_block();
block_to_insert.header.block_header_without_hash.block_number =
BlockNumber(block_number);
block_to_insert.header.block_hash =
starknet_api::block::BlockHash(Felt::from(block_number as u128));
blocks.insert(block_to_insert, StateDiff::default());
blocks.pre_confirmed_block.header.block_header_without_hash.block_number =
BlockNumber(block_number).unchecked_next();
}
let block_numbers: Vec<u64> = blocks
.get_blocks(None, None)
.unwrap()
.iter()
.map(|block| block.block_number().0)
.collect();
assert_eq!(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], block_numbers);
let block_numbers: Vec<u64> = blocks
.get_blocks(Some(BlockId::Number(7)), None)
.unwrap()
.iter()
.map(|block| block.block_number().0)
.collect();
assert_eq!(vec![7, 8, 9, 10, 11], block_numbers);
let block_numbers: Vec<u64> = blocks
.get_blocks(Some(BlockId::Number(7)), Some(BlockId::Tag(BlockTag::Latest)))
.unwrap()
.iter()
.map(|block| block.block_number().0)
.collect();
assert_eq!(vec![7, 8, 9, 10], block_numbers);
}
#[test]
fn block_number_from_block_id_should_return_correct_result() {
let mut blocks = StarknetBlocks::new(0, None);
let mut block_to_insert = StarknetBlock::create_pre_confirmed_block();
blocks.pre_confirmed_block = block_to_insert.clone();
// latest block returns none, because collection is empty
assert!(blocks.block_number_from_block_id(&BlockId::Tag(BlockTag::Latest)).is_none());
// pre-confirmed block returns some
assert!(blocks.block_number_from_block_id(&BlockId::Tag(BlockTag::PreConfirmed)).is_some());
let block_hash = block_to_insert.generate_hash().unwrap();
block_to_insert.header.block_header_without_hash.block_number = BlockNumber(10);
block_to_insert.header.block_hash = starknet_api::block::BlockHash(block_hash);
blocks.insert(block_to_insert, StateDiff::default());
// returns block number, even if the block number is not present in the collection
assert!(blocks.block_number_from_block_id(&BlockId::Number(11)).is_none());
assert!(blocks.block_number_from_block_id(&BlockId::Number(10)).is_some());
// returns none because there is no block with the given hash
assert!(blocks.block_number_from_block_id(&BlockId::Hash(Felt::ONE)).is_none());
assert!(blocks.block_number_from_block_id(&BlockId::Tag(BlockTag::Latest)).is_some());
assert!(blocks.block_number_from_block_id(&BlockId::Tag(BlockTag::PreConfirmed)).is_some());
assert!(blocks.block_number_from_block_id(&BlockId::Hash(block_hash)).is_some());
}
#[test]
fn get_blocks_with_filter() {
let mut blocks = StarknetBlocks::default();
let last_block_number = 11;
for block_number in 2..=last_block_number {
let mut block_to_insert = StarknetBlock::create_pre_confirmed_block();
block_to_insert.header.block_header_without_hash.block_number =
BlockNumber(block_number);
block_to_insert.header.block_hash =
starknet_api::block::BlockHash(Felt::from(block_number as u128));
blocks.insert(block_to_insert.clone(), StateDiff::default());
// last block will be a pre_confirmed block
if block_number == last_block_number {
blocks.pre_confirmed_block = block_to_insert;
}
}
// check blocks len
assert!(blocks.hash_to_block.len() == 10);
// 1. None, None
// no filter
assert_eq!(blocks.get_blocks(None, None).unwrap().len(), 10);
// 2. Some, None
assert_eq!(blocks.get_blocks(Some(BlockId::Number(9)), None).unwrap().len(), 3);
// invalid from filter, should return err block not found
assert!(blocks.get_blocks(Some(BlockId::Number(12)), None).is_err());
// last block should be returned
assert_eq!(blocks.get_blocks(Some(BlockId::Number(11)), None).unwrap().len(), 1);
// from filter using hash
assert_eq!(blocks.get_blocks(Some(BlockId::Hash(Felt::from(9))), None).unwrap().len(), 3);
// from filter using tag
assert_eq!(blocks.get_blocks(Some(BlockId::Tag(BlockTag::Latest)), None).unwrap().len(), 1);
assert_eq!(
blocks.get_blocks(Some(BlockId::Tag(BlockTag::PreConfirmed)), None).unwrap().len(),
1
);
// 3. None, Some
// to filter using block number
assert_eq!(blocks.get_blocks(None, Some(BlockId::Number(9))).unwrap().len(), 8);
// to filter using invalid block number
assert!(blocks.get_blocks(None, Some(BlockId::Number(0))).is_err());
// to filter using hash
assert_eq!(blocks.get_blocks(None, Some(BlockId::Hash(Felt::from(9)))).unwrap().len(), 8);
// to filter using invalid hash
assert!(blocks.get_blocks(None, Some(BlockId::Hash(Felt::ZERO))).is_err());
// to filter using tag
assert_eq!(
blocks.get_blocks(None, Some(BlockId::Tag(BlockTag::Latest))).unwrap().len(),
10
);
assert_eq!(
blocks.get_blocks(None, Some(BlockId::Tag(BlockTag::PreConfirmed))).unwrap().len(),
10
);
// First block as to_block query param, should return empty collection
assert_eq!(blocks.get_blocks(None, Some(BlockId::Number(2))).unwrap().len(), 1);
// invalid to filter, should return err block not found
assert!(blocks.get_blocks(None, Some(BlockId::Number(1))).is_err());
// 4. Some, Some
// from block number to block number
assert_eq!(
blocks.get_blocks(Some(BlockId::Number(2)), Some(BlockId::Number(9))).unwrap().len(),
8
);
// from block number to block hash
assert_eq!(
blocks
.get_blocks(Some(BlockId::Number(2)), Some(BlockId::Hash(Felt::from(9))))
.unwrap()
.len(),
8
);
// from first block to latest/pre-confirmed, should return all blocks
assert_eq!(
blocks
.get_blocks(Some(BlockId::Number(2)), Some(BlockId::Tag(BlockTag::Latest)))
.unwrap()
.len(),
10
);
assert_eq!(
blocks
.get_blocks(Some(BlockId::Number(2)), Some(BlockId::Tag(BlockTag::PreConfirmed)))
.unwrap()
.len(),
10
);
// from last block to first block should return empty result
assert!(
blocks
.get_blocks(Some(BlockId::Number(10)), Some(BlockId::Number(2)))
.unwrap()
.is_empty()
);
// from last block to latest/pre-confirmed, should return 1 block
assert_eq!(
blocks
.get_blocks(Some(BlockId::Number(11)), Some(BlockId::Tag(BlockTag::Latest)))
.unwrap()
.len(),
1
);
assert_eq!(
blocks
.get_blocks(Some(BlockId::Number(11)), Some(BlockId::Tag(BlockTag::PreConfirmed)))
.unwrap()
.len(),
1
);
// bigger range than actual blocks in the collection, should return err
assert!(blocks.get_blocks(Some(BlockId::Number(0)), Some(BlockId::Number(1000))).is_err());
// from block hash to block_hash
assert_eq!(
blocks
.get_blocks(Some(BlockId::Hash(Felt::TWO)), Some(BlockId::Hash(Felt::from(9))))
.unwrap()
.len(),
8
);
assert!(
blocks
.get_blocks(Some(BlockId::Hash(Felt::TWO)), Some(BlockId::Hash(Felt::ZERO)))
.is_err()
);
assert!(
blocks
.get_blocks(Some(BlockId::Hash(Felt::from(10))), Some(BlockId::Hash(Felt::from(5))))
.unwrap()
.is_empty()
);
// from block hash to block number
assert_eq!(
blocks
.get_blocks(Some(BlockId::Hash(Felt::TWO)), Some(BlockId::Number(9)))
.unwrap()
.len(),
8
);
// from last block hash to latest/pre-confirmed
assert_eq!(
blocks
.get_blocks(
Some(BlockId::Hash(Felt::from(11))),
Some(BlockId::Tag(BlockTag::Latest))
)
.unwrap()
.len(),
1
);
assert_eq!(
blocks
.get_blocks(
Some(BlockId::Hash(Felt::from(11))),
Some(BlockId::Tag(BlockTag::PreConfirmed))
)
.unwrap()
.len(),
1
);
// from tag to tag
assert_eq!(
blocks
.get_blocks(
Some(BlockId::Tag(BlockTag::Latest)),
Some(BlockId::Tag(BlockTag::Latest))
)
.unwrap()
.len(),
1
);
assert_eq!(
blocks
.get_blocks(
Some(BlockId::Tag(BlockTag::Latest)),
Some(BlockId::Tag(BlockTag::PreConfirmed))
)
.unwrap()
.len(),
1
);
assert_eq!(
blocks
.get_blocks(
Some(BlockId::Tag(BlockTag::PreConfirmed)),
Some(BlockId::Tag(BlockTag::Latest))
)
.unwrap()
.len(),
1
);
assert_eq!(
blocks
.get_blocks(
Some(BlockId::Tag(BlockTag::PreConfirmed)),
Some(BlockId::Tag(BlockTag::PreConfirmed))
)
.unwrap()
.len(),
1
);
// from tag to block number/hash
assert_eq!(
blocks
.get_blocks(Some(BlockId::Tag(BlockTag::Latest)), Some(BlockId::Number(11)))
.unwrap()
.len(),
1
);
assert_eq!(
blocks
.get_blocks(
Some(BlockId::Tag(BlockTag::Latest)),
Some(BlockId::Hash(Felt::from(11)))
)
.unwrap()
.len(),
1
);
assert_eq!(
blocks
.get_blocks(Some(BlockId::Tag(BlockTag::PreConfirmed)), Some(BlockId::Number(11)))
.unwrap()
.len(),
1
);
assert_eq!(
blocks
.get_blocks(
Some(BlockId::Tag(BlockTag::PreConfirmed)),
Some(BlockId::Hash(Felt::from(11)))
)
.unwrap()
.len(),
1
);
assert!(
blocks
.get_blocks(Some(BlockId::Tag(BlockTag::Latest)), Some(BlockId::Number(2)))
.unwrap()
.is_empty()
);
assert!(
blocks
.get_blocks(Some(BlockId::Tag(BlockTag::Latest)), Some(BlockId::Hash(Felt::TWO)))
.unwrap()
.is_empty()
);
}
#[test]
fn get_by_block_id_is_correct() {
let mut blocks = StarknetBlocks::default();
let mut block_to_insert = StarknetBlock::create_pre_confirmed_block();
block_to_insert.header.block_hash =
starknet_api::block::BlockHash(block_to_insert.generate_hash().unwrap());
block_to_insert.header.block_header_without_hash.block_number = BlockNumber(10);
blocks.pre_confirmed_block = block_to_insert.clone();
blocks.insert(block_to_insert.clone(), StateDiff::default());
let extracted_block = blocks.get_by_block_id(&BlockId::Number(10)).unwrap();
assert!(block_to_insert == extracted_block.clone());
let extracted_block =
blocks.get_by_block_id(&BlockId::Hash(block_to_insert.block_hash())).unwrap();
assert!(block_to_insert == extracted_block.clone());
let extracted_block = blocks.get_by_block_id(&BlockId::Tag(BlockTag::Latest)).unwrap();
assert!(block_to_insert == extracted_block.clone());
let extracted_block =
blocks.get_by_block_id(&BlockId::Tag(BlockTag::PreConfirmed)).unwrap();
assert!(block_to_insert == extracted_block.clone());
match blocks.get_by_block_id(&BlockId::Number(11)) {
None => (),
_ => panic!("Expected none"),
}
}
#[test]
fn correct_block_linking_via_parent_hash() {
let mut blocks = StarknetBlocks::default();
for block_number in 0..3 {
let mut block = StarknetBlock::create_pre_confirmed_block();
block.status = BlockStatus::AcceptedOnL2;
block.header.block_header_without_hash.block_number = BlockNumber(block_number);
block.set_block_hash(block.generate_hash().unwrap());
blocks.insert(block, StateDiff::default());
}
assert!(
blocks
.get_by_num(&BlockNumber(0))
.unwrap()
.header
.block_header_without_hash
.parent_hash
== BlockHash::default()
);
assert!(
blocks.get_by_num(&BlockNumber(0)).unwrap().header.block_hash
== blocks
.get_by_num(&BlockNumber(1))
.unwrap()
.header
.block_header_without_hash
.parent_hash
);
assert!(
blocks.get_by_num(&BlockNumber(1)).unwrap().header.block_hash
== blocks
.get_by_num(&BlockNumber(2))
.unwrap()
.header
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | true |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/predeployed.rs | crates/starknet-devnet-core/src/starknet/predeployed.rs | use blockifier::state::state_api::State;
use starknet_rs_core::types::Felt;
use starknet_rs_core::utils::cairo_short_string_to_felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::felt::felt_from_prefixed_hex;
use crate::constants::{
CHARGEABLE_ACCOUNT_ADDRESS, UDC_CONTRACT, UDC_CONTRACT_ADDRESS, UDC_CONTRACT_CLASS_HASH,
UDC_LEGACY_CONTRACT, UDC_LEGACY_CONTRACT_ADDRESS, UDC_LEGACY_CONTRACT_CLASS_HASH,
};
use crate::error::{DevnetResult, Error};
use crate::state::StarknetState;
use crate::system_contract::SystemContract;
use crate::utils::get_storage_var_address;
pub(crate) fn create_erc20_at_address_extended(
contract_address: Felt,
class_hash: Felt,
contract_class_json_str: &str,
) -> DevnetResult<SystemContract> {
let erc20_fee_contract =
SystemContract::new_cairo1(class_hash, contract_address, contract_class_json_str)?;
Ok(erc20_fee_contract)
}
/// Set initial values of ERC20 contract storage
pub(crate) fn initialize_erc20_at_address(
state: &mut StarknetState,
contract_address: Felt,
erc20_name: &str,
erc20_symbol: &str,
) -> DevnetResult<()> {
let contract_address = ContractAddress::new(contract_address)?;
for (storage_var_name, storage_value) in [
(
"ERC20_name",
cairo_short_string_to_felt(erc20_name)
.map_err(|err| Error::UnexpectedInternalError { msg: err.to_string() })?,
),
(
"ERC20_symbol",
cairo_short_string_to_felt(erc20_symbol)
.map_err(|err| Error::UnexpectedInternalError { msg: err.to_string() })?,
),
("ERC20_decimals", 18.into()),
("permitted_minter", felt_from_prefixed_hex(CHARGEABLE_ACCOUNT_ADDRESS)?),
] {
let storage_var_address = get_storage_var_address(storage_var_name, &[])?.into();
state.set_storage_at(contract_address.into(), storage_var_address, storage_value)?;
}
Ok(())
}
pub(crate) fn create_udc() -> DevnetResult<SystemContract> {
let udc =
SystemContract::new_cairo1(UDC_CONTRACT_CLASS_HASH, UDC_CONTRACT_ADDRESS, UDC_CONTRACT)?;
Ok(udc)
}
pub(crate) fn create_legacy_udc() -> DevnetResult<SystemContract> {
let udc = SystemContract::new_cairo0(
UDC_LEGACY_CONTRACT_CLASS_HASH,
UDC_LEGACY_CONTRACT_ADDRESS,
UDC_LEGACY_CONTRACT,
)?;
Ok(udc)
}
#[cfg(test)]
pub(crate) mod tests {
use starknet_rs_core::types::Felt;
use crate::constants::{STRK_ERC20_CONTRACT_CLASS, STRK_ERC20_CONTRACT_CLASS_HASH};
use crate::error::DevnetResult;
use crate::system_contract::SystemContract;
pub(crate) fn create_erc20_at_address(contract_address: Felt) -> DevnetResult<SystemContract> {
let erc20_fee_contract = SystemContract::new_cairo1(
STRK_ERC20_CONTRACT_CLASS_HASH,
contract_address,
STRK_ERC20_CONTRACT_CLASS,
)?;
Ok(erc20_fee_contract)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/defaulter.rs | crates/starknet-devnet-core/src/starknet/defaulter.rs | use blockifier::execution::contract_class::RunnableCompiledClass;
use blockifier::state::errors::StateError;
use blockifier::state::state_api::StateResult;
use starknet_api::core::{ClassHash, ContractAddress, Nonce, PatriciaKey};
use starknet_api::state::StorageKey;
use starknet_rs_core::types::Felt;
use starknet_types::contract_class::convert_codegen_to_blockifier_compiled_class;
use tokio::sync::oneshot;
use tracing::debug;
use super::starknet_config::ForkConfig;
#[derive(thiserror::Error, Debug)]
enum OriginError {
#[error("Error in communication with forking origin: {0}")]
CommunicationError(String),
#[error("Received invalid response from forking origin: {0}")]
FormatError(String),
#[error("Received JSON response from forking origin, but no result property in it")]
NoResult,
}
impl OriginError {
fn from_status_code(status_code: reqwest::StatusCode) -> Self {
let additional_info = match status_code {
reqwest::StatusCode::TOO_MANY_REQUESTS => {
"This means your program is making Devnet send too many requests to the forking \
origin. 1) It could be a temporary issue, so try re-running your program. 2) If \
forking is not crucial for your use-case, disable it. 3) Try changing the forking \
URL. 4) Consider adding short sleeps to the program from which you are \
interacting with Devnet."
}
_ => "",
};
OriginError::CommunicationError(format!("{status_code}. {additional_info}"))
}
}
/// Used for interacting with the origin in forking mode. The calls are blocking. Only handles the
/// basic state reading necessary for contract interaction. For other RPC methods, see
/// `OriginForwarder`
#[derive(Debug, Clone)]
struct BlockingOriginReader {
url: url::Url,
block_number: u64,
client: reqwest::Client,
}
impl BlockingOriginReader {
fn new(url: url::Url, block_number: u64) -> Self {
Self { url, block_number, client: reqwest::Client::new() }
}
/// Sends the `body` as JSON payload of a POST request. Expects JSON in response and returns it.
fn blocking_post(&self, body: serde_json::Value) -> Result<serde_json::Value, OriginError> {
let (tx, rx) = oneshot::channel();
let client = self.client.clone();
let url = self.url.clone();
tokio::spawn(async move {
let result = async {
let mut retries_left = 3;
loop {
retries_left -= 1;
// Send tx with JSON payload
let resp = client
.post(url.clone())
.json(&body)
.send()
.await
.map_err(|e| OriginError::CommunicationError(format!("{e:?}")))?;
match resp.status() {
reqwest::StatusCode::OK => {
// Load json from response body
break resp.json::<serde_json::Value>().await.map_err(|e| {
OriginError::FormatError(format!("Expected JSON response: {e}"))
});
}
// If server-side error like 503, retry
other if other.as_u16() % 100 == 5 && retries_left > 0 => {
let sleep_secs = 1;
debug!(
"Forking origin responded with status {other}. Retries left: \
{retries_left}. Retrying after {sleep_secs} s."
);
tokio::time::sleep(std::time::Duration::from_secs(sleep_secs)).await;
}
unretriable => {
break Err(OriginError::from_status_code(unretriable));
}
}
}
}
.await;
tx.send(result)
});
tokio::task::block_in_place(move || {
rx.blocking_recv()
.map_err(|e| OriginError::CommunicationError(format!("Channel error: {e}")))?
})
}
fn send_body(
&self,
method: &str,
mut params: serde_json::Value,
) -> Result<serde_json::Value, OriginError> {
params["block_id"] = serde_json::json!({
"block_number": self.block_number
});
let body = serde_json::json!({
"jsonrpc": "2.0",
"method": method,
"params": params,
"id": 0,
});
match self.blocking_post(body.clone()) {
Ok(resp_json_value) => {
let result = &resp_json_value["result"];
if result.is_null() {
// the received response is assumed to mean that the origin doesn't contain the
// requested resource
debug!("Forking origin response contains no 'result': {resp_json_value}");
Err(OriginError::NoResult)
} else {
debug!("Forking origin received {body:?} and successfully returned: {result}");
Ok(result.clone())
}
}
Err(other_err) => {
debug!("Forking origin received {body:?} and returned error: {other_err:?}");
Err(other_err)
}
}
}
}
/// Used for forking - reads from the origin if Some(origin_reader); otherwise returns the default
/// or Err, depending on the method
#[derive(Clone, Debug, Default)]
pub struct StarknetDefaulter {
origin_reader: Option<BlockingOriginReader>,
}
impl StarknetDefaulter {
pub fn new(fork_config: ForkConfig) -> Self {
let origin_reader =
if let (Some(fork_url), Some(block)) = (fork_config.url, fork_config.block_number) {
Some(BlockingOriginReader::new(fork_url, block))
} else {
None
};
Self { origin_reader }
}
pub fn get_storage_at(
&self,
contract_address: ContractAddress,
key: StorageKey,
) -> StateResult<Felt> {
if let Some(origin) = &self.origin_reader {
origin.get_storage_at(contract_address, key)
} else {
Ok(Default::default())
}
}
pub fn get_nonce_at(&self, contract_address: ContractAddress) -> StateResult<Nonce> {
if let Some(origin) = &self.origin_reader {
origin.get_nonce_at(contract_address)
} else {
Ok(Default::default())
}
}
pub fn get_compiled_class(&self, class_hash: ClassHash) -> StateResult<RunnableCompiledClass> {
if let Some(origin) = &self.origin_reader {
origin.get_compiled_class(class_hash)
} else {
Err(StateError::UndeclaredClassHash(class_hash))
}
}
pub fn get_class_hash_at(&self, contract_address: ContractAddress) -> StateResult<ClassHash> {
if let Some(origin) = &self.origin_reader {
origin.get_class_hash_at(contract_address)
} else {
Ok(Default::default())
}
}
}
fn convert_json_value_to_felt(json_value: serde_json::Value) -> StateResult<Felt> {
serde_json::from_value(json_value).map_err(|e| StateError::StateReadError(e.to_string()))
}
fn convert_patricia_key_to_hex(key: PatriciaKey) -> String {
key.key().to_hex_string()
}
// Same as StateReader, but with &self instead of &mut self
impl BlockingOriginReader {
fn get_storage_at(
&self,
contract_address: ContractAddress,
key: StorageKey,
) -> StateResult<Felt> {
let storage = match self.send_body(
"starknet_getStorageAt",
serde_json::json!({
"contract_address": convert_patricia_key_to_hex(contract_address.0),
"key": convert_patricia_key_to_hex(key.0),
}),
) {
Err(OriginError::NoResult) => Default::default(),
Err(other_error) => return Err(StateError::StateReadError(other_error.to_string())),
Ok(value) => convert_json_value_to_felt(value)?,
};
Ok(storage)
}
fn get_nonce_at(&self, contract_address: ContractAddress) -> StateResult<Nonce> {
let nonce = match self.send_body(
"starknet_getNonce",
serde_json::json!({
"contract_address": convert_patricia_key_to_hex(contract_address.0),
}),
) {
Err(OriginError::NoResult) => Default::default(),
Err(other_error) => return Err(StateError::StateReadError(other_error.to_string())),
Ok(value) => Nonce(convert_json_value_to_felt(value)?),
};
Ok(nonce)
}
fn get_class_hash_at(&self, contract_address: ContractAddress) -> StateResult<ClassHash> {
let class_hash = match self.send_body(
"starknet_getClassHashAt",
serde_json::json!({
"contract_address": convert_patricia_key_to_hex(contract_address.0),
}),
) {
Err(OriginError::NoResult) => Default::default(),
Err(other_error) => return Err(StateError::StateReadError(other_error.to_string())),
Ok(value) => ClassHash(convert_json_value_to_felt(value)?),
};
Ok(class_hash)
}
fn get_compiled_class(&self, class_hash: ClassHash) -> StateResult<RunnableCompiledClass> {
match self.send_body(
"starknet_getClass",
serde_json::json!({
"class_hash": class_hash.0.to_hex_string(),
}),
) {
Err(OriginError::NoResult) => Err(StateError::UndeclaredClassHash(class_hash)),
Err(other_error) => Err(StateError::StateReadError(other_error.to_string())),
Ok(value) => {
let contract_class: starknet_rs_core::types::ContractClass =
serde_json::from_value(value)
.map_err(|e| StateError::StateReadError(e.to_string()))?;
convert_codegen_to_blockifier_compiled_class(contract_class)
.map_err(|e| StateError::StateReadError(e.to_string()))
}
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/starknet_config.rs | crates/starknet-devnet-core/src/starknet/starknet_config.rs | use std::num::NonZeroU128;
use clap::Error;
use serde::{Serialize, Serializer};
use starknet_rs_core::types::Felt;
use starknet_types::chain_id::ChainId;
use starknet_types::contract_class::ContractClass;
use starknet_types::rpc::state::Balance;
use starknet_types::traits::HashProducer;
use url::Url;
use crate::constants::{
CAIRO_1_ACCOUNT_CONTRACT_SIERRA, DEVNET_DEFAULT_CHAIN_ID, DEVNET_DEFAULT_INITIAL_BALANCE,
DEVNET_DEFAULT_L1_DATA_GAS_PRICE, DEVNET_DEFAULT_L1_GAS_PRICE, DEVNET_DEFAULT_L2_GAS_PRICE,
DEVNET_DEFAULT_TEST_SEED, DEVNET_DEFAULT_TOTAL_ACCOUNTS, ETH_ERC20_CONTRACT_CLASS,
ETH_ERC20_CONTRACT_CLASS_HASH, MAXIMUM_CONTRACT_BYTECODE_SIZE, MAXIMUM_CONTRACT_CLASS_SIZE,
MAXIMUM_SIERRA_LENGTH, STRK_ERC20_CONTRACT_CLASS, STRK_ERC20_CONTRACT_CLASS_HASH,
};
#[derive(Copy, Clone, Debug, clap::ValueEnum, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum DumpOn {
Exit,
Block,
Request,
}
#[derive(Default, Copy, Clone, Debug, Eq, PartialEq, clap::ValueEnum, Serialize)]
#[serde(rename_all = "snake_case")]
#[clap(rename_all = "snake_case")]
pub enum StateArchiveCapacity {
#[default]
None,
Full,
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum BlockGenerationOn {
Transaction,
Demand,
Interval(u64),
}
#[derive(Clone, Debug, Serialize)]
pub struct ClassSizeConfig {
pub maximum_contract_class_size: u64,
pub maximum_contract_bytecode_size: u64,
pub maximum_sierra_length: u64,
}
impl Default for ClassSizeConfig {
fn default() -> Self {
Self {
maximum_contract_class_size: MAXIMUM_CONTRACT_CLASS_SIZE,
maximum_contract_bytecode_size: MAXIMUM_CONTRACT_BYTECODE_SIZE,
maximum_sierra_length: MAXIMUM_SIERRA_LENGTH,
}
}
}
impl std::str::FromStr for BlockGenerationOn {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"transaction" => Ok(BlockGenerationOn::Transaction),
"demand" => Ok(BlockGenerationOn::Demand),
value => {
let interval_value = value
.parse::<u64>()
.map_err(|_| Error::new(clap::error::ErrorKind::InvalidValue))?;
if interval_value > 0 {
Ok(BlockGenerationOn::Interval(interval_value))
} else {
Err(Error::new(clap::error::ErrorKind::InvalidValue))
}
}
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ForkConfig {
#[serde(serialize_with = "serialize_config_url")]
pub url: Option<Url>,
pub block_number: Option<u64>,
#[serde(skip)]
pub block_hash: Option<Felt>,
}
pub fn serialize_config_url<S>(url: &Option<Url>, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match url {
Some(url) => serializer.serialize_str(url.as_ref()),
None => serializer.serialize_none(),
}
}
pub fn serialize_initial_balance<S>(balance: &Balance, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&balance.to_str_radix(10))
}
pub fn serialize_chain_id<S>(chain_id: &ChainId, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&format!("{chain_id}"))
}
#[derive(Clone, Debug, Serialize)]
pub struct StarknetConfig {
pub seed: u32,
pub total_accounts: u8,
#[serde(skip_serializing)]
pub account_contract_class: ContractClass,
pub account_contract_class_hash: Felt,
#[serde(serialize_with = "serialize_initial_balance")]
pub predeployed_accounts_initial_balance: Balance,
pub start_time: Option<u64>,
pub gas_price_wei: NonZeroU128,
pub gas_price_fri: NonZeroU128,
pub data_gas_price_wei: NonZeroU128,
pub data_gas_price_fri: NonZeroU128,
pub l2_gas_price_wei: NonZeroU128,
pub l2_gas_price_fri: NonZeroU128,
#[serde(serialize_with = "serialize_chain_id")]
pub chain_id: ChainId,
pub dump_on: Option<DumpOn>,
pub dump_path: Option<String>,
pub block_generation_on: BlockGenerationOn,
pub lite_mode: bool,
pub state_archive: StateArchiveCapacity,
pub fork_config: ForkConfig,
pub eth_erc20_class_hash: Felt,
pub strk_erc20_class_hash: Felt,
#[serde(skip_serializing)]
pub eth_erc20_contract_class: String,
#[serde(skip_serializing)]
pub strk_erc20_contract_class: String,
#[serde(skip_serializing)]
pub predeclare_argent: bool,
pub class_size_config: ClassSizeConfig,
}
impl StarknetConfig {
pub fn uses_pre_confirmed_block(&self) -> bool {
match self.block_generation_on {
BlockGenerationOn::Transaction => false,
BlockGenerationOn::Demand | BlockGenerationOn::Interval(_) => true,
}
}
}
#[allow(clippy::unwrap_used)]
impl Default for StarknetConfig {
fn default() -> Self {
// unwrapping is safe here because the contract is hardcoded and we know it wont fail
let account_contract_class: ContractClass =
ContractClass::cairo_1_from_sierra_json_str(CAIRO_1_ACCOUNT_CONTRACT_SIERRA)
.unwrap()
.into();
StarknetConfig {
seed: DEVNET_DEFAULT_TEST_SEED,
total_accounts: DEVNET_DEFAULT_TOTAL_ACCOUNTS,
// same here
account_contract_class_hash: account_contract_class.generate_hash().unwrap(),
account_contract_class,
predeployed_accounts_initial_balance: DEVNET_DEFAULT_INITIAL_BALANCE.into(),
start_time: None,
gas_price_wei: DEVNET_DEFAULT_L1_GAS_PRICE.get().try_into().unwrap(),
gas_price_fri: DEVNET_DEFAULT_L1_GAS_PRICE.get().try_into().unwrap(),
data_gas_price_wei: DEVNET_DEFAULT_L1_DATA_GAS_PRICE.get().try_into().unwrap(),
data_gas_price_fri: DEVNET_DEFAULT_L1_DATA_GAS_PRICE.get().try_into().unwrap(),
l2_gas_price_wei: DEVNET_DEFAULT_L2_GAS_PRICE.get().try_into().unwrap(),
l2_gas_price_fri: DEVNET_DEFAULT_L2_GAS_PRICE.get().try_into().unwrap(),
chain_id: DEVNET_DEFAULT_CHAIN_ID,
dump_on: None,
dump_path: None,
block_generation_on: BlockGenerationOn::Transaction,
lite_mode: false,
state_archive: StateArchiveCapacity::default(),
fork_config: ForkConfig::default(),
eth_erc20_class_hash: ETH_ERC20_CONTRACT_CLASS_HASH,
strk_erc20_class_hash: STRK_ERC20_CONTRACT_CLASS_HASH,
eth_erc20_contract_class: ETH_ERC20_CONTRACT_CLASS.to_string(),
strk_erc20_contract_class: STRK_ERC20_CONTRACT_CLASS.to_string(),
predeclare_argent: false,
class_size_config: ClassSizeConfig::default(),
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/add_invoke_transaction.rs | crates/starknet-devnet-core/src/starknet/add_invoke_transaction.rs | use blockifier::transaction::account_transaction::ExecutionFlags;
use blockifier::transaction::transactions::ExecutableTransaction;
use starknet_types::contract_address::ContractAddress;
use starknet_types::felt::TransactionHash;
use starknet_types::rpc::transactions::invoke_transaction_v3::InvokeTransactionV3;
use starknet_types::rpc::transactions::{
BroadcastedInvokeTransaction, InvokeTransaction, Transaction, TransactionWithHash,
};
use super::Starknet;
use crate::error::{DevnetResult, Error, TransactionValidationError};
pub fn add_invoke_transaction(
starknet: &mut Starknet,
broadcasted_invoke_transaction: BroadcastedInvokeTransaction,
) -> DevnetResult<TransactionHash> {
if !broadcasted_invoke_transaction.are_gas_bounds_valid() {
return Err(TransactionValidationError::InsufficientResourcesForValidate.into());
}
if broadcasted_invoke_transaction.is_only_query() {
return Err(Error::UnsupportedAction {
msg: "only-query transactions are not supported".to_string(),
});
}
let sn_api_transaction =
broadcasted_invoke_transaction.create_sn_api_invoke(&starknet.chain_id().to_felt())?;
let transaction_hash = sn_api_transaction.tx_hash.0;
let invoke_transaction = match broadcasted_invoke_transaction {
BroadcastedInvokeTransaction::V3(ref v3) => {
Transaction::Invoke(InvokeTransaction::V3(InvokeTransactionV3::new(v3)))
}
};
let validate = !(Starknet::is_account_impersonated(
&mut starknet.pre_confirmed_state,
&starknet.cheats,
&ContractAddress::from(sn_api_transaction.sender_address()),
)?);
let block_context = starknet.block_context.clone();
let strict_nonce_check = broadcasted_invoke_transaction
.requires_strict_nonce_check(starknet.config.uses_pre_confirmed_block());
let state = &mut starknet.get_state().state;
let execution_info = blockifier::transaction::account_transaction::AccountTransaction {
tx: starknet_api::executable_transaction::AccountTransaction::Invoke(sn_api_transaction),
execution_flags: ExecutionFlags {
only_query: false,
charge_fee: true,
validate,
strict_nonce_check,
},
}
.execute(state, &block_context);
let execution_info = execution_info?;
let transaction = TransactionWithHash::new(transaction_hash, invoke_transaction);
starknet.handle_accepted_transaction(transaction, execution_info)?;
Ok(transaction_hash)
}
#[cfg(test)]
mod tests {
use blockifier::state::state_api::StateReader;
use nonzero_ext::nonzero;
use starknet_api::block::BlockNumber;
use starknet_api::core::Nonce;
use starknet_rs_core::types::{Felt, TransactionExecutionStatus};
use starknet_rs_core::utils::get_selector_from_name;
use starknet_types::constants::QUERY_VERSION_OFFSET;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use starknet_types::contract_storage_key::ContractStorageKey;
use starknet_types::num_bigint::BigUint;
use starknet_types::rpc::gas_modification::GasModification;
use starknet_types::rpc::state::Balance;
use starknet_types::rpc::transactions::{
BroadcastedInvokeTransaction, TransactionFinalityStatus,
};
use starknet_types::traits::HashProducer;
use crate::account::{Account, FeeToken};
use crate::constants::{
self, DEVNET_DEFAULT_CHAIN_ID, DEVNET_DEFAULT_STARTING_BLOCK_NUMBER,
ETH_ERC20_CONTRACT_ADDRESS,
};
use crate::error::{Error, TransactionValidationError};
use crate::starknet::starknet_config::BlockGenerationOn;
use crate::starknet::{Starknet, predeployed};
use crate::state::CustomState;
use crate::traits::{Accounted, Deployed, HashIdentifiedMut};
use crate::utils::exported_test_utils::dummy_cairo_0_contract_class;
use crate::utils::get_storage_var_address;
use crate::utils::test_utils::{
cairo_0_account_without_validations, dummy_contract_address, dummy_felt, dummy_key_pair,
resource_bounds_with_price_1, test_invoke_transaction_v3,
};
#[test]
fn invoke_transaction_v3_with_only_query_version_should_return_an_error() {
let mut invoke_transaction = test_invoke_transaction_v3(
dummy_contract_address(),
dummy_contract_address(),
dummy_felt(),
&[Felt::from(10)],
0, // nonce
resource_bounds_with_price_1(1, 0, 0),
);
let BroadcastedInvokeTransaction::V3(ref mut tx_v3) = invoke_transaction;
tx_v3.common.version = Felt::THREE + QUERY_VERSION_OFFSET;
let result = Starknet::default().add_invoke_transaction(invoke_transaction);
match result {
Err(crate::error::Error::UnsupportedAction { msg }) => {
assert_eq!(msg, "only-query transactions are not supported")
}
other => panic!("Unexpected result: {other:?}"),
};
}
fn biguint_to_u64(b: &BigUint) -> u64 {
let parts = b.to_u64_digits();
assert_eq!(parts.len(), 1);
parts[0]
}
#[test]
fn invoke_transaction_v3_successful_execution_with_only_l1_gas() {
let (mut starknet, account, contract_address, increase_balance_selector, _) = setup();
let account_address = account.get_address();
let initial_balance =
account.get_balance(&mut starknet.pre_confirmed_state, FeeToken::STRK).unwrap();
let invoke_transaction = test_invoke_transaction_v3(
account_address,
contract_address,
increase_balance_selector,
&[Felt::from(10)],
0, // nonce
resource_bounds_with_price_1(biguint_to_u64(&initial_balance), 0, 0),
);
let transaction_hash = starknet.add_invoke_transaction(invoke_transaction).unwrap();
let retrieved_tx = starknet.transactions.get_by_hash_mut(&transaction_hash).unwrap();
assert_eq!(retrieved_tx.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_eq!(retrieved_tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
assert!(
account.get_balance(&mut starknet.pre_confirmed_state, FeeToken::STRK).unwrap()
< initial_balance
);
}
#[test]
fn invoke_transaction_v3_successful_execution_with_all_three_gas_bounds() {
let (mut starknet, account, contract_address, increase_balance_selector, _) = setup();
let account_address = account.get_address();
let initial_balance =
account.get_balance(&mut starknet.pre_confirmed_state, FeeToken::STRK).unwrap();
// dividing by 10, otherwise it fails with gas exceeding user balance
let gas_amount = biguint_to_u64(&initial_balance) / 10;
let invoke_transaction = test_invoke_transaction_v3(
account_address,
contract_address,
increase_balance_selector,
&[Felt::from(10)],
0,
resource_bounds_with_price_1(gas_amount, gas_amount, gas_amount),
);
let transaction_hash = starknet.add_invoke_transaction(invoke_transaction).unwrap();
let retrieved_tx = starknet.transactions.get_by_hash_mut(&transaction_hash).unwrap();
assert_eq!(retrieved_tx.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_eq!(retrieved_tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
assert!(
account.get_balance(&mut starknet.pre_confirmed_state, FeeToken::STRK).unwrap()
< initial_balance
);
}
#[test]
fn invoke_transaction_v3_with_invalid_gas_amounts() {
let (mut starknet, account, contract_address, increase_balance_selector, _) = setup();
let account_address = account.get_address();
let balance: u64 = account
.get_balance(&mut starknet.pre_confirmed_state, FeeToken::STRK)
.unwrap()
.to_string()
.parse()
.unwrap();
assert!(balance > 0);
// either only l1_gas is allowed or all three must be set, otherwise invalid
for (l1_gas, l1_data_gas, l2_gas) in
[(balance, 0, 1), (0, 0, 1), (0, balance, 0), (balance, balance, 0), (0, 0, 0)]
{
let invoke_transaction = test_invoke_transaction_v3(
account_address,
contract_address,
increase_balance_selector,
&[Felt::from(10)],
0,
resource_bounds_with_price_1(l1_gas, l1_data_gas, l2_gas),
);
match starknet.add_invoke_transaction(invoke_transaction) {
Err(Error::TransactionValidationError(
TransactionValidationError::InsufficientResourcesForValidate,
)) => {}
other => {
panic!("Wrong result: {other:?}")
}
}
}
}
#[test]
fn invoke_transaction_v1_successfully_changes_storage() {
let (
mut starknet,
account,
contract_address,
increase_balance_selector,
balance_var_storage_address,
) = setup();
let blockifier_address = contract_address.into();
let storage_key = (*balance_var_storage_address.get_storage_key()).into();
let account_address = account.get_address();
let resource_bounds = resource_bounds_with_price_1(0, 1000, 1e6 as u64);
let invoke_transaction = test_invoke_transaction_v3(
account_address,
contract_address,
increase_balance_selector,
&[Felt::from(10)],
0, // nonce
resource_bounds.clone(),
);
// invoke transaction
let transaction_hash = starknet.add_invoke_transaction(invoke_transaction).unwrap();
let retrieved_tx = starknet.transactions.get_by_hash_mut(&transaction_hash).unwrap();
assert_eq!(retrieved_tx.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_eq!(retrieved_tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
// check storage
assert_eq!(
starknet.pre_confirmed_state.get_storage_at(blockifier_address, storage_key).unwrap(),
Felt::from(10)
);
let invoke_transaction = test_invoke_transaction_v3(
account_address,
contract_address,
increase_balance_selector,
&[Felt::from(15)],
1, // nonce
resource_bounds,
);
// invoke transaction again
let transaction_hash = starknet.add_invoke_transaction(invoke_transaction).unwrap();
let retrieved_tx = starknet.transactions.get_by_hash_mut(&transaction_hash).unwrap();
assert_eq!(retrieved_tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
assert_eq!(retrieved_tx.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_eq!(
starknet.pre_confirmed_state.get_storage_at(blockifier_address, storage_key).unwrap(),
Felt::from(25)
);
}
#[test]
fn invoke_transaction_v3_with_zero_gas_bounds_should_return_error() {
let nonce = 0;
let tx = test_invoke_transaction_v3(
dummy_contract_address(),
dummy_contract_address(),
dummy_felt(),
&[Felt::ZERO],
nonce,
resource_bounds_with_price_1(0, 0, 0),
);
match Starknet::default().add_invoke_transaction(tx) {
Err(Error::TransactionValidationError(
TransactionValidationError::InsufficientResourcesForValidate,
)) => {}
other => panic!("Unexpected result: {other:?}"),
}
}
#[test]
fn invoke_tx_should_return_error_if_nonce_repeated_in_block_on_demand_mode() {
invoke_tx_should_fail_if_nonce_repeated(
BlockGenerationOn::Demand,
TransactionFinalityStatus::PreConfirmed,
);
}
#[test]
fn invoke_tx_should_return_error_if_nonce_repeated_in_block_on_tx_mode() {
invoke_tx_should_fail_if_nonce_repeated(
BlockGenerationOn::Transaction,
TransactionFinalityStatus::AcceptedOnL2,
);
}
fn invoke_tx_should_fail_if_nonce_repeated(
block_generation_mode: BlockGenerationOn,
expected_finality_status: TransactionFinalityStatus,
) {
let (mut starknet, account, contract_address, increase_balance_selector, _) = setup();
starknet.config.block_generation_on = block_generation_mode;
let account_address = account.get_address();
let tx_nonce = 0;
let l2_gas = 1e6 as u64;
let tx = test_invoke_transaction_v3(
account_address,
contract_address,
increase_balance_selector,
&[dummy_felt()],
tx_nonce,
resource_bounds_with_price_1(0, 1000, l2_gas),
);
let transaction_hash = starknet.add_invoke_transaction(tx.clone()).unwrap();
let retrieved_tx = starknet.transactions.get_by_hash_mut(&transaction_hash).unwrap();
assert_eq!(retrieved_tx.finality_status, expected_finality_status);
assert_eq!(retrieved_tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
// new tx with more l2_gas
let tx = test_invoke_transaction_v3(
account_address,
contract_address,
increase_balance_selector,
&[dummy_felt()],
tx_nonce,
// if less, bounced back instead of accepted+reverted
resource_bounds_with_price_1(0, 1000, l2_gas * 2),
);
match starknet.add_invoke_transaction(tx) {
Err(Error::TransactionValidationError(
TransactionValidationError::InvalidTransactionNonce {
address,
account_nonce,
incoming_tx_nonce,
},
)) => assert_eq!(
(address, account_nonce, incoming_tx_nonce),
(account_address, Nonce(Felt::ONE), Nonce(Felt::from(tx_nonce)))
),
other => panic!("Unexpected result: {other:?}"),
}
}
#[test]
fn nonce_should_be_incremented_if_invoke_reverted() {
let (mut starknet, account, contract_address, increase_balance_selector, _) = setup();
let account_address = account.get_address().into();
let initial_nonce = starknet
.pre_confirmed_state
.get_nonce_at(account_address)
.unwrap()
.0
.try_into()
.unwrap();
assert_eq!(initial_nonce, 0);
let tx = test_invoke_transaction_v3(
account_address.into(),
contract_address,
increase_balance_selector,
&[dummy_felt()],
initial_nonce,
// if less, bounced back instead of accepted+reverted
resource_bounds_with_price_1(0, 128, 520_000),
);
let transaction_hash = starknet.add_invoke_transaction(tx).unwrap();
let retrieved_tx = starknet.transactions.get_by_hash_mut(&transaction_hash).unwrap();
assert_eq!(retrieved_tx.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_eq!(retrieved_tx.execution_result.status(), TransactionExecutionStatus::Reverted);
let nonce_after_reverted =
starknet.pre_confirmed_state.get_nonce_at(account_address).unwrap();
assert_eq!(nonce_after_reverted, Nonce(Felt::ONE));
}
#[test]
fn invoke_tx_should_fail_if_nonce_higher_than_expected_in_block_on_tx_mode() {
let (mut starknet, account, contract_address, increase_balance_selector, _) = setup();
starknet.config.block_generation_on = BlockGenerationOn::Transaction;
let tx_nonce = 1; // too high
let tx = test_invoke_transaction_v3(
account.get_address(),
contract_address,
increase_balance_selector,
&[dummy_felt()],
tx_nonce,
resource_bounds_with_price_1(0, 1000, 1e6 as u64),
);
match starknet.add_invoke_transaction(tx) {
Err(Error::TransactionValidationError(
TransactionValidationError::InvalidTransactionNonce {
address,
account_nonce,
incoming_tx_nonce,
},
)) => assert_eq!(
(address, account_nonce, incoming_tx_nonce),
(account.get_address(), Nonce(Felt::ZERO), Nonce(Felt::from(tx_nonce)))
),
other => panic!("Unexpected result: {other:?}"),
}
}
#[test]
fn invoke_tx_should_pass_if_nonce_higher_than_expected_in_block_on_demand_mode() {
let (mut starknet, account, contract_address, increase_balance_selector, _) = setup();
starknet.config.block_generation_on = BlockGenerationOn::Demand;
let nonce = 1; // higher than the expected 0
let tx = test_invoke_transaction_v3(
account.get_address(),
contract_address,
increase_balance_selector,
&[dummy_felt()],
nonce,
resource_bounds_with_price_1(0, 1000, 1e6 as u64),
);
let tx_hash = starknet.add_invoke_transaction(tx).unwrap();
let retrieved_tx = starknet.transactions.get_by_hash_mut(&tx_hash).unwrap();
assert_eq!(retrieved_tx.finality_status, TransactionFinalityStatus::PreConfirmed);
assert_eq!(retrieved_tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
assert_eq!(retrieved_tx.block_number, Some(BlockNumber(0)));
}
#[test]
fn txs_with_successive_nonces_are_acceptable_in_the_same_block() {
let (mut starknet, account, contract_address, increase_balance_selector, _) = setup();
starknet.config.block_generation_on = BlockGenerationOn::Demand;
for nonce in 1..=2 {
let tx = test_invoke_transaction_v3(
account.get_address(),
contract_address,
increase_balance_selector,
&[dummy_felt()],
nonce,
resource_bounds_with_price_1(0, 1000, 1e6 as u64),
);
let tx_hash = starknet.add_invoke_transaction(tx).unwrap();
let retrieved_tx = starknet.transactions.get_by_hash_mut(&tx_hash).unwrap();
assert_eq!(retrieved_tx.finality_status, TransactionFinalityStatus::PreConfirmed);
assert_eq!(
retrieved_tx.execution_result.status(),
TransactionExecutionStatus::Succeeded
);
assert_eq!(retrieved_tx.block_number, Some(BlockNumber(0)));
}
}
/// Initialize starknet object with: erc20 contract, account contract and simple contract that
/// has a function increase_balance
fn setup() -> (Starknet, Account, ContractAddress, Felt, ContractStorageKey) {
let mut starknet = Starknet::default();
// deploy erc20 contracts
let eth_erc_20_contract =
predeployed::tests::create_erc20_at_address(ETH_ERC20_CONTRACT_ADDRESS).unwrap();
eth_erc_20_contract.deploy(&mut starknet.pre_confirmed_state).unwrap();
let strk_erc_20_contract =
predeployed::tests::create_erc20_at_address(constants::STRK_ERC20_CONTRACT_ADDRESS)
.unwrap();
strk_erc_20_contract.deploy(&mut starknet.pre_confirmed_state).unwrap();
// deploy account contract
let account_without_validations_contract_class = cairo_0_account_without_validations();
let account_without_validations_class_hash =
account_without_validations_contract_class.generate_hash().unwrap();
let account = Account::new(
Balance::from(1000000000_u32),
dummy_key_pair(),
account_without_validations_class_hash,
"Custom",
ContractClass::Cairo0(account_without_validations_contract_class),
eth_erc_20_contract.get_address(),
strk_erc_20_contract.get_address(),
)
.unwrap();
account.deploy(&mut starknet.pre_confirmed_state).unwrap();
// dummy contract
let dummy_contract = dummy_cairo_0_contract_class();
// check if increase_balance function is present in the contract class
let increase_balance_selector = get_selector_from_name("increase_balance").unwrap();
let sn_api_class: starknet_api::deprecated_contract_class::ContractClass =
dummy_contract.clone().try_into().unwrap();
sn_api_class
.entry_points_by_type
.get(&starknet_api::contract_class::EntryPointType::External)
.unwrap()
.iter()
.find(|el| el.selector.0 == increase_balance_selector)
.unwrap();
let dummy_contract_address = ContractAddress::new(Felt::from(5)).unwrap();
let dummy_contract_class_hash = dummy_contract.generate_hash().unwrap();
let storage_key = get_storage_var_address("balance", &[]).unwrap();
let contract_storage_key = ContractStorageKey::new(dummy_contract_address, storage_key);
// declare dummy contract
starknet
.pre_confirmed_state
.declare_contract_class(dummy_contract_class_hash, None, dummy_contract.into())
.unwrap();
// deploy dummy contract
starknet
.pre_confirmed_state
.predeploy_contract(dummy_contract_address, dummy_contract_class_hash)
.unwrap();
// change storage of dummy contract
starknet.block_context = Starknet::init_block_context(
nonzero!(1u128),
nonzero!(1u128),
nonzero!(1u128),
nonzero!(1u128),
nonzero!(1u128),
nonzero!(1u128),
constants::ETH_ERC20_CONTRACT_ADDRESS,
constants::STRK_ERC20_CONTRACT_ADDRESS,
DEVNET_DEFAULT_CHAIN_ID,
DEVNET_DEFAULT_STARTING_BLOCK_NUMBER,
);
starknet.next_block_gas = GasModification {
gas_price_wei: nonzero!(1u128),
data_gas_price_wei: nonzero!(1u128),
l2_gas_price_wei: nonzero!(1u128),
gas_price_fri: nonzero!(1u128),
data_gas_price_fri: nonzero!(1u128),
l2_gas_price_fri: nonzero!(1u128),
};
starknet.restart_pre_confirmed_block().unwrap();
(starknet, account, dummy_contract_address, increase_balance_selector, contract_storage_key)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/add_l1_handler_transaction.rs | crates/starknet-devnet-core/src/starknet/add_l1_handler_transaction.rs | use alloy::primitives::B256;
use blockifier::transaction::transactions::ExecutableTransaction;
use starknet_types::felt::TransactionHash;
use starknet_types::rpc::transactions::l1_handler_transaction::L1HandlerTransaction;
use starknet_types::rpc::transactions::{Transaction, TransactionWithHash};
use tracing::trace;
use super::Starknet;
use crate::error::DevnetResult;
pub fn add_l1_handler_transaction(
starknet: &mut Starknet,
transaction: L1HandlerTransaction,
) -> DevnetResult<TransactionHash> {
let executable_tx = transaction.create_sn_api_transaction(starknet.chain_id().to_felt())?;
let transaction_hash = executable_tx.tx_hash.0;
trace!("Executing L1 handler transaction [{:#064x}]", transaction_hash);
let execution_info =
blockifier::transaction::transaction_execution::Transaction::L1Handler(executable_tx)
.execute(&mut starknet.pre_confirmed_state.state, &starknet.block_context)?;
starknet.handle_accepted_transaction(
TransactionWithHash::new(transaction_hash, Transaction::L1Handler(transaction.clone())),
execution_info,
)?;
// If L1 tx hash present, store the generated L2 tx hash in its messaging entry.
// Not done as part of `handle_transaction_result` as it is specific to this tx type.
if let Some(l1_tx_hash) = transaction.l1_transaction_hash {
starknet
.messaging
.l1_to_l2_tx_hashes
.entry(B256::new(*l1_tx_hash.as_bytes()))
.or_default()
.push(transaction_hash);
}
Ok(transaction_hash)
}
#[cfg(test)]
mod tests {
// Constants taken from test_estimate_message_fee.rs.
const WHITELISTED_L1_ADDRESS: &str = "0x8359E4B0152ed5A731162D3c7B0D8D56edB165A0";
use nonzero_ext::nonzero;
use starknet_rs_core::types::{Felt, TransactionExecutionStatus};
use starknet_rs_core::utils::get_selector_from_name;
use starknet_types::chain_id::ChainId;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use starknet_types::felt::felt_from_prefixed_hex;
use starknet_types::rpc::state::Balance;
use starknet_types::rpc::transactions::l1_handler_transaction::L1HandlerTransaction;
use starknet_types::rpc::transactions::{
ExecutionInvocation, TransactionFinalityStatus, TransactionTrace,
};
use starknet_types::traits::HashProducer;
use crate::account::Account;
use crate::constants::{
self, DEVNET_DEFAULT_CHAIN_ID, DEVNET_DEFAULT_STARTING_BLOCK_NUMBER,
ETH_ERC20_CONTRACT_ADDRESS, STRK_ERC20_CONTRACT_ADDRESS,
};
use crate::starknet::{Starknet, predeployed};
use crate::state::CustomState;
use crate::traits::{Deployed, HashIdentifiedMut};
use crate::utils::exported_test_utils::dummy_cairo_l1l2_contract;
use crate::utils::test_utils::{cairo_0_account_without_validations, dummy_key_pair};
#[test]
fn l1_handler_transaction_hash_computation() {
let from_address = "0x000000000000000000000000be3C44c09bc1a3566F3e1CA12e5AbA0fA4Ca72Be";
let to_address = "0x039dc79e64f4bb3289240f88e0bae7d21735bef0d1a51b2bf3c4730cb16983e1";
let selector = "0x02f15cff7b0eed8b9beb162696cf4e3e0e35fa7032af69cd1b7d2ac67a13f40f";
let nonce = 783082_u128;
let fee = 30000_u128;
let calldata: Vec<Felt> =
vec![felt_from_prefixed_hex(from_address).unwrap(), Felt::ONE, Felt::TWO];
let transaction = L1HandlerTransaction {
contract_address: ContractAddress::new(felt_from_prefixed_hex(to_address).unwrap())
.unwrap(),
entry_point_selector: felt_from_prefixed_hex(selector).unwrap(),
calldata,
nonce: nonce.into(),
paid_fee_on_l1: fee,
..Default::default()
};
let l1_handler_transaction_hash = transaction.compute_hash(ChainId::Testnet.to_felt());
let transaction_hash = felt_from_prefixed_hex(
"0x1b24ea8dd9e0cb603043958b27a8569635ea13568883cc155130591b7ffe37a",
)
.unwrap();
assert_eq!(transaction.version, Felt::ZERO);
assert_eq!(l1_handler_transaction_hash, transaction_hash);
}
#[test]
fn l1_handler_transaction_successful_execution() {
let (mut starknet, _account_address, contract_address, deposit_selector, _) = setup();
let transaction = get_l1_handler_tx(
felt_from_prefixed_hex(WHITELISTED_L1_ADDRESS).unwrap(),
contract_address,
deposit_selector,
vec![Felt::from(11), Felt::from(9999)],
);
let transaction_hash = starknet.add_l1_handler_transaction(transaction).unwrap();
let state_transaction = starknet.transactions.get_by_hash_mut(&transaction_hash).unwrap();
assert_eq!(state_transaction.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_eq!(
state_transaction.execution_result.status(),
TransactionExecutionStatus::Succeeded
);
}
#[test]
fn l1_handler_transaction_not_l1_handler_entrypoint() {
let (mut starknet, _account_address, contract_address, _, withdraw_selector) = setup();
let tx = get_l1_handler_tx(
felt_from_prefixed_hex(WHITELISTED_L1_ADDRESS).unwrap(),
contract_address,
withdraw_selector,
vec![Felt::from(11), Felt::from(9999)],
);
let tx_hash = starknet.add_l1_handler_transaction(tx).unwrap();
let trace = match starknet.get_transaction_trace_by_hash(tx_hash) {
Ok(TransactionTrace::L1Handler(trace)) => trace,
other => panic!("Unexpected trace response: {other:?}"),
};
match trace.function_invocation {
ExecutionInvocation::Reverted(reversion) => {
assert!(reversion.revert_reason.contains("ENTRYPOINT_NOT_FOUND"));
}
other => panic!("Unexpected invocation: {other:?}"),
}
}
/// Builds a `L1HandlerTransaction` from the given parameters. The nonce, fee and chain_id are
/// fixed: nonce: 783082
/// fee: 30000
/// chain_id: ChainId::Testnet
fn get_l1_handler_tx(
from_address: Felt,
contract_address: ContractAddress,
entry_point_selector: Felt,
payload: Vec<Felt>,
) -> L1HandlerTransaction {
let nonce = 783082_u128;
let fee = 30000_u128;
let mut calldata = payload;
calldata.insert(0, from_address);
L1HandlerTransaction {
contract_address,
entry_point_selector,
calldata,
nonce: nonce.into(),
paid_fee_on_l1: fee,
..Default::default()
}
}
/// Initializes a starknet object with: l1l2 dummy contract that has two functions for
/// messaging: `deposit` - the `#l1_handler` to receive message from L1, which accept 3 args
/// `from_address`, `user`, `amount`. `withdraw` - the function to send message to L1 with 3
/// args `MESSAGE_WITHDRAW=0`, user, `amount`.
fn setup() -> (Starknet, ContractAddress, ContractAddress, Felt, Felt) {
let mut starknet = Starknet::default();
// deploy erc20 contract
let eth_erc_20_contract =
predeployed::tests::create_erc20_at_address(ETH_ERC20_CONTRACT_ADDRESS).unwrap();
eth_erc_20_contract.deploy(&mut starknet.pre_confirmed_state).unwrap();
let strk_erc_20_contract =
predeployed::tests::create_erc20_at_address(STRK_ERC20_CONTRACT_ADDRESS).unwrap();
strk_erc_20_contract.deploy(&mut starknet.pre_confirmed_state).unwrap();
// deploy account contract
let account_without_validations_contract_class = cairo_0_account_without_validations();
let account_without_validations_class_hash =
account_without_validations_contract_class.generate_hash().unwrap();
let account = Account::new(
Balance::from(10000_u32),
dummy_key_pair(),
account_without_validations_class_hash,
"Custom",
ContractClass::Cairo0(account_without_validations_contract_class),
eth_erc_20_contract.get_address(),
strk_erc_20_contract.get_address(),
)
.unwrap();
account.deploy(&mut starknet.pre_confirmed_state).unwrap();
// dummy contract
let dummy_contract = dummy_cairo_l1l2_contract();
let sn_api_class: starknet_api::deprecated_contract_class::ContractClass =
dummy_contract.clone().try_into().unwrap();
let withdraw_selector = get_selector_from_name("withdraw").unwrap();
let deposit_selector = get_selector_from_name("deposit").unwrap();
// check if withdraw function is present in the contract class
sn_api_class
.entry_points_by_type
.get(&starknet_api::contract_class::EntryPointType::External)
.unwrap()
.iter()
.find(|el| el.selector.0 == withdraw_selector)
.unwrap();
// check if deposit function is present in the contract class
sn_api_class
.entry_points_by_type
.get(&starknet_api::contract_class::EntryPointType::L1Handler)
.unwrap()
.iter()
.find(|el| el.selector.0 == deposit_selector)
.unwrap();
let dummy_contract_address = ContractAddress::new(Felt::from(5)).unwrap();
let dummy_contract_class_hash = dummy_contract.generate_hash().unwrap();
// declare dummy contract
starknet
.pre_confirmed_state
.declare_contract_class(dummy_contract_class_hash, None, dummy_contract.into())
.unwrap();
// deploy dummy contract
starknet
.pre_confirmed_state
.predeploy_contract(dummy_contract_address, dummy_contract_class_hash)
.unwrap();
starknet.block_context = Starknet::init_block_context(
nonzero!(1u128),
nonzero!(1u128),
nonzero!(1u128),
nonzero!(1u128),
nonzero!(1u128),
nonzero!(1u128),
constants::ETH_ERC20_CONTRACT_ADDRESS,
constants::STRK_ERC20_CONTRACT_ADDRESS,
DEVNET_DEFAULT_CHAIN_ID,
DEVNET_DEFAULT_STARTING_BLOCK_NUMBER,
);
starknet.restart_pre_confirmed_block().unwrap();
(
starknet,
account.get_address(),
dummy_contract_address,
deposit_selector,
withdraw_selector,
)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/get_class_impls.rs | crates/starknet-devnet-core/src/starknet/get_class_impls.rs | use blockifier::state::state_api::StateReader;
use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
use starknet_types::compile_sierra_contract;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use starknet_types::felt::ClassHash;
use starknet_types::rpc::block::{BlockId, BlockStatus, BlockTag};
use crate::error::{DevnetResult, Error, StateError};
use crate::starknet::Starknet;
use crate::state::BlockNumberOrPreConfirmed;
pub fn get_class_hash_at_impl(
starknet: &mut Starknet,
block_id: &BlockId,
contract_address: ContractAddress,
) -> DevnetResult<ClassHash> {
let state = starknet.get_mut_state_at(block_id)?;
let core_address = contract_address.into();
let class_hash = state.get_class_hash_at(core_address)?;
if class_hash == Default::default() { Err(Error::ContractNotFound) } else { Ok(class_hash.0) }
}
pub fn get_class_impl(
starknet: &Starknet,
block_id: &BlockId,
class_hash: ClassHash,
) -> DevnetResult<ContractClass> {
let requested_block = starknet.get_block(block_id)?;
// the underlying logic only works with block number or pre_confirmed tag
let block_number_or_pre_confirmed = match requested_block.status {
BlockStatus::PreConfirmed => BlockNumberOrPreConfirmed::PreConfirmed,
BlockStatus::AcceptedOnL2 | BlockStatus::AcceptedOnL1 => {
BlockNumberOrPreConfirmed::Number(requested_block.block_number().0)
}
BlockStatus::Rejected => return Err(Error::NoBlock),
};
// Returns sierra for cairo1; returns the only artifact for cairo0.
match starknet
.rpc_contract_classes
.read()
.get_class(&class_hash, &block_number_or_pre_confirmed)
{
Some(class) => Ok(class.clone()),
None => Err(Error::StateError(StateError::NoneClassHash(class_hash))),
}
}
pub fn get_class_at_impl(
starknet: &mut Starknet,
block_id: &BlockId,
contract_address: ContractAddress,
) -> DevnetResult<ContractClass> {
let class_hash = starknet.get_class_hash_at(block_id, contract_address)?;
starknet.get_class(block_id, class_hash)
}
pub fn get_compiled_casm_impl(
starknet: &Starknet,
class_hash: ClassHash,
) -> DevnetResult<CasmContractClass> {
let contract_class = get_class_impl(starknet, &BlockId::Tag(BlockTag::Latest), class_hash)?;
match contract_class {
ContractClass::Cairo1(sierra_contract_class) => {
let mut casm = compile_sierra_contract(&sierra_contract_class)?;
casm.pythonic_hints = None; // removes the extra key from serialized form
Ok(casm)
}
ContractClass::Cairo0(_) => Err(Error::StateError(StateError::NoneCasmClass(class_hash))),
}
}
#[cfg(test)]
mod tests {
use starknet_rs_core::types::Felt;
use starknet_types::contract_class::ContractClass;
use starknet_types::rpc::block::BlockId;
use starknet_types::rpc::transactions::BroadcastedDeclareTransaction;
use crate::error::Error;
use crate::starknet::starknet_config::StateArchiveCapacity;
use crate::starknet::tests::setup_starknet_with_no_signature_check_account_and_state_capacity;
use crate::utils::test_utils::{
broadcasted_declare_tx_v3_of_dummy_class, resource_bounds_with_price_1,
};
#[test]
fn get_sierra_class() {
let (mut starknet, account) =
setup_starknet_with_no_signature_check_account_and_state_capacity(
1e18 as u128,
StateArchiveCapacity::Full,
);
let declare_txn = broadcasted_declare_tx_v3_of_dummy_class(
account.account_address,
Felt::ZERO,
resource_bounds_with_price_1(0, 1000, 1e9 as u64),
);
let expected: ContractClass = declare_txn.contract_class.clone().into();
let (_, class_hash) = starknet
.add_declare_transaction(BroadcastedDeclareTransaction::V3(Box::new(declare_txn)))
.unwrap();
let block_number = starknet.get_latest_block().unwrap().block_number();
let contract_class =
starknet.get_class(&BlockId::Number(block_number.0), class_hash).unwrap();
assert_eq!(contract_class, expected)
}
#[test]
fn get_class_hash_at_generated_accounts() {
let (mut starknet, account) =
setup_starknet_with_no_signature_check_account_and_state_capacity(
1e8 as u128,
StateArchiveCapacity::Full,
);
let block_number = starknet.get_latest_block().unwrap().block_number();
let block_id = BlockId::Number(block_number.0);
let class_hash = starknet.get_class_hash_at(&block_id, account.account_address).unwrap();
let expected = account.class_hash;
assert_eq!(class_hash, expected);
}
#[test]
fn get_class_hash_at_generated_accounts_without_state_archive() {
let (mut starknet, account) =
setup_starknet_with_no_signature_check_account_and_state_capacity(
1e8 as u128,
StateArchiveCapacity::None,
);
let block_number = starknet.get_latest_block().unwrap().block_number();
let block_id = BlockId::Number(block_number.0);
starknet.create_block().unwrap(); // makes the queried block non-latest (and unsupported)
let class_hash = starknet.get_class_hash_at(&block_id, account.account_address);
match class_hash.err().unwrap() {
Error::NoStateAtBlock { .. } => (),
_ => panic!("Should fail with NoStateAtBlock."),
}
}
#[test]
fn get_class_at_generated_accounts() {
let (mut starknet, account) =
setup_starknet_with_no_signature_check_account_and_state_capacity(
1e8 as u128,
StateArchiveCapacity::Full,
);
let block_number = starknet.get_latest_block().unwrap().block_number();
let block_id = BlockId::Number(block_number.0);
let contract_class = starknet.get_class_at(&block_id, account.account_address).unwrap();
assert_eq!(contract_class, account.contract_class);
}
#[test]
fn attempt_getting_class_from_block_before_declaration() {
let (mut starknet, account) =
setup_starknet_with_no_signature_check_account_and_state_capacity(
1e8 as u128,
StateArchiveCapacity::Full,
);
let block_number = starknet.get_latest_block().unwrap().block_number();
// class not present before the latest block
let block_id = BlockId::Number(block_number.0 - 1);
match starknet.get_class_at(&block_id, account.account_address) {
Err(Error::ContractNotFound) => (),
other => panic!("Got unexpected resp: {other:?}"),
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/estimations.rs | crates/starknet-devnet-core/src/starknet/estimations.rs | use blockifier::fee::fee_utils::{self};
use blockifier::state::cached_state::CachedState;
use blockifier::state::state_api::StateReader;
use blockifier::transaction::account_transaction::ExecutionFlags;
use blockifier::transaction::objects::HasRelatedFeeType;
use blockifier::transaction::transaction_execution::Transaction;
use blockifier::transaction::transactions::ExecutableTransaction;
use starknet_api::transaction::fields::{GasVectorComputationMode, Tip};
use starknet_rs_core::types::{Felt, MsgFromL1, PriceUnit};
use starknet_types::contract_address::ContractAddress;
use starknet_types::rpc::block::BlockId as CustomBlockId;
use starknet_types::rpc::estimate_message_fee::{EstimateMessageFeeRequest, FeeEstimateWrapper};
use starknet_types::rpc::transactions::BroadcastedTransaction;
use crate::error::{ContractExecutionError, DevnetResult, Error};
use crate::starknet::Starknet;
use crate::utils::get_versioned_constants;
pub fn estimate_fee(
starknet: &mut Starknet,
block_id: &CustomBlockId,
transactions: &[BroadcastedTransaction],
charge_fee: Option<bool>,
validate: Option<bool>,
return_error_on_reverted_execution: bool,
) -> DevnetResult<Vec<FeeEstimateWrapper>> {
let chain_id = starknet.chain_id().to_felt();
let block_context = starknet.block_context.clone();
let cheats = starknet.cheats.clone();
let using_pre_confirmed_block = starknet.config.uses_pre_confirmed_block();
let state = starknet.get_mut_state_at(block_id)?;
let transactions = {
transactions
.iter()
.map(|txn| {
let skip_validate_due_to_impersonation =
Starknet::should_transaction_skip_validation_if_sender_is_impersonated(
state, &cheats, txn,
)?;
let validate = skip_validate_due_to_impersonation
.then_some(false)
.or(validate)
.unwrap_or(true);
Ok((
txn.to_sn_api_account_transaction(&chain_id)?,
validate,
txn.gas_vector_computation_mode(),
txn.requires_strict_nonce_check(using_pre_confirmed_block),
))
})
.collect::<DevnetResult<Vec<_>>>()?
};
let mut transactional_state = CachedState::create_transactional(&mut state.state);
transactions
.into_iter()
.enumerate()
.map(|(idx, (transaction, validate, gas_vector_computation_mode, strict_nonce_check))| {
let estimate_fee_result = estimate_transaction_fee(
&mut transactional_state,
&block_context,
Transaction::Account(
blockifier::transaction::account_transaction::AccountTransaction {
tx: transaction,
execution_flags: ExecutionFlags {
only_query: true,
charge_fee: charge_fee.unwrap_or(false),
validate,
strict_nonce_check,
},
},
),
return_error_on_reverted_execution,
gas_vector_computation_mode,
);
match estimate_fee_result {
Ok(estimated_fee) => Ok(estimated_fee),
// reverted transactions are failing with ExecutionError, but index is set to 0, so
// we override the index property
Err(Error::ContractExecutionError(execution_error)) => {
Err(Error::ContractExecutionErrorInSimulation {
failure_index: idx,
execution_error,
})
}
Err(err) => Err(Error::ContractExecutionErrorInSimulation {
failure_index: idx,
execution_error: ContractExecutionError::from(err.to_string()),
}),
}
})
.collect()
}
pub fn estimate_message_fee(
starknet: &mut Starknet,
block_id: &CustomBlockId,
message: MsgFromL1,
) -> DevnetResult<FeeEstimateWrapper> {
let estimate_message_fee = EstimateMessageFeeRequest::new(*block_id, message);
let block_context = starknet.block_context.clone();
let state = starknet.get_mut_state_at(block_id)?;
let address = ContractAddress::new(estimate_message_fee.get_to_address())?;
state.assert_contract_deployed(address)?;
let mut transactional_state = CachedState::create_transactional(&mut state.state);
let l1_transaction = estimate_message_fee.create_blockifier_l1_transaction()?;
estimate_transaction_fee(
&mut transactional_state,
&block_context,
Transaction::L1Handler(l1_transaction),
true,
// Using only L1 gas, because msgs coming from L1 are L1 txs, with their own gas cost
GasVectorComputationMode::NoL2Gas,
)
}
fn estimate_transaction_fee<S: StateReader>(
transactional_state: &mut CachedState<S>,
block_context: &blockifier::context::BlockContext,
transaction: Transaction,
return_error_on_reverted_execution: bool,
gas_vector_computation_mode: GasVectorComputationMode,
) -> DevnetResult<FeeEstimateWrapper> {
let transaction_execution_info = transaction.execute(transactional_state, block_context)?;
match transaction_execution_info.revert_error {
Some(revert_error) if return_error_on_reverted_execution => {
match revert_error {
blockifier::transaction::objects::RevertError::Execution(stack) => {
return Err(Error::ContractExecutionError(ContractExecutionError::from(stack)));
}
blockifier::transaction::objects::RevertError::PostExecution(fee_check_error) => {
return Err(fee_check_error.into());
}
};
}
_ => {}
}
let gas_vector = transaction_execution_info.receipt.resources.to_gas_vector(
&get_versioned_constants(),
block_context.block_info().use_kzg_da,
&gas_vector_computation_mode,
);
let fee_type = match &transaction {
Transaction::Account(tx) => tx.fee_type(),
Transaction::L1Handler(tx) => tx.fee_type(),
};
// Tip is 0 Gfri according to https://spaceshard.slack.com/archives/C03031Y0LKC/p1751873286905609?thread_ts=1751635985.448309&cid=C03031Y0LKC
let total_fee =
fee_utils::get_fee_by_gas_vector(block_context.block_info(), gas_vector, &fee_type, Tip(0));
let gas_prices = &block_context.block_info().gas_prices;
let l1_gas_price = gas_prices.l1_gas_price(&fee_type).get();
let data_gas_price = gas_prices.l1_data_gas_price(&fee_type).get();
let l2_gas_price = gas_prices.l2_gas_price(&fee_type).get();
let unit = match fee_type {
starknet_api::block::FeeType::Strk => PriceUnit::Fri,
starknet_api::block::FeeType::Eth => PriceUnit::Wei,
};
Ok(FeeEstimateWrapper {
l1_gas_consumed: Felt::from(gas_vector.l1_gas),
l1_gas_price: Felt::from(l1_gas_price),
l1_data_gas_consumed: Felt::from(gas_vector.l1_data_gas),
l1_data_gas_price: Felt::from(data_gas_price),
l2_gas_consumed: Felt::from(gas_vector.l2_gas),
l2_gas_price: Felt::from(l2_gas_price),
overall_fee: Felt::from(total_fee.0),
unit,
})
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/cheats.rs | crates/starknet-devnet-core/src/starknet/cheats.rs | use std::collections::HashSet;
use starknet_types::contract_address::ContractAddress;
#[derive(Default, Clone)]
pub(crate) struct Cheats {
impersonated_accounts: HashSet<ContractAddress>,
auto_impersonate: bool,
}
impl Cheats {
pub(crate) fn impersonate_account(&mut self, account: ContractAddress) {
self.impersonated_accounts.insert(account);
}
pub(crate) fn stop_impersonating_account(&mut self, account: &ContractAddress) {
self.impersonated_accounts.remove(account);
}
pub(crate) fn is_impersonated(&self, account: &ContractAddress) -> bool {
self.auto_impersonate || self.impersonated_accounts.contains(account)
}
pub(crate) fn set_auto_impersonate(&mut self, auto_impersonation: bool) {
self.auto_impersonate = auto_impersonation;
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/mod.rs | crates/starknet-devnet-core/src/starknet/mod.rs | use std::num::NonZeroU128;
use std::sync::Arc;
use alloy::primitives::B256;
use blockifier::context::{BlockContext, ChainInfo, TransactionContext};
use blockifier::execution::common_hints::ExecutionMode;
use blockifier::state::cached_state::CachedState;
use blockifier::state::state_api::StateReader;
use blockifier::transaction::account_transaction::{AccountTransaction, ExecutionFlags};
use blockifier::transaction::errors::TransactionExecutionError;
use blockifier::transaction::objects::TransactionExecutionInfo;
use blockifier::transaction::transactions::ExecutableTransaction;
use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
use parking_lot::RwLock;
use starknet_api::block::{
BlockInfo, BlockNumber, BlockTimestamp, FeeType, GasPrice, GasPricePerToken, GasPriceVector,
GasPrices,
};
use starknet_api::block_hash::block_hash_calculator::calculate_block_commitments;
use starknet_api::core::SequencerContractAddress;
use starknet_api::data_availability::DataAvailabilityMode;
use starknet_api::state::ThinStateDiff as ThinStateDiffImported;
use starknet_api::transaction::fields::{GasVectorComputationMode, Tip};
use starknet_api::transaction::{TransactionHasher, TransactionVersion};
use starknet_rs_core::types::{Felt, Hash256, MsgFromL1};
use starknet_rs_core::utils::get_selector_from_name;
use starknet_rs_signers::{LocalWallet, Signer, SigningKey};
use starknet_types::chain_id::ChainId;
use starknet_types::contract_address::ContractAddress;
use starknet_types::contract_class::ContractClass;
use starknet_types::emitted_event::EmittedEvent;
use starknet_types::felt::{
BlockHash, ClassHash, TransactionHash, felt_from_prefixed_hex, split_biguint,
};
use starknet_types::num_bigint::BigUint;
use starknet_types::patricia_key::PatriciaKey;
use starknet_types::rpc::block::{
Block, BlockHeader, BlockId as CustomBlockId, BlockResult, BlockStatus,
BlockTag as CustomBlockTag, PreConfirmedBlock, PreConfirmedBlockHeader,
};
use starknet_types::rpc::estimate_message_fee::FeeEstimateWrapper;
use starknet_types::rpc::gas_modification::{GasModification, GasModificationRequest};
use starknet_types::rpc::state::{
PreConfirmedStateUpdate, StateUpdate, StateUpdateResult, ThinStateDiff,
};
use starknet_types::rpc::transaction_receipt::TransactionReceipt;
use starknet_types::rpc::transactions::broadcasted_invoke_transaction_v3::BroadcastedInvokeTransactionV3;
use starknet_types::rpc::transactions::l1_handler_transaction::L1HandlerTransaction;
use starknet_types::rpc::transactions::{
BlockTransactionTrace, BroadcastedDeclareTransaction, BroadcastedDeployAccountTransaction,
BroadcastedInvokeTransaction, BroadcastedTransaction, BroadcastedTransactionCommonV3,
L1HandlerTransactionStatus, ResourceBoundsWrapper, SimulatedTransaction, SimulationFlag,
TransactionFinalityStatus, TransactionStatus, TransactionTrace, TransactionType,
TransactionWithHash, TransactionWithReceipt, Transactions,
};
use starknet_types::traits::HashProducer;
use tracing::{error, info};
use self::cheats::Cheats;
use self::defaulter::StarknetDefaulter;
use self::predeployed::initialize_erc20_at_address;
use self::starknet_config::{StarknetConfig, StateArchiveCapacity};
use self::transaction_trace::create_trace;
use crate::account::Account;
use crate::blocks::{StarknetBlock, StarknetBlocks};
use crate::constants::{
ARGENT_CONTRACT_CLASS_HASH, ARGENT_CONTRACT_SIERRA, ARGENT_MULTISIG_CONTRACT_CLASS_HASH,
ARGENT_MULTISIG_CONTRACT_SIERRA, CHARGEABLE_ACCOUNT_ADDRESS, CHARGEABLE_ACCOUNT_PRIVATE_KEY,
DEVNET_DEFAULT_CHAIN_ID, DEVNET_DEFAULT_L1_DATA_GAS_PRICE, DEVNET_DEFAULT_L1_GAS_PRICE,
DEVNET_DEFAULT_L2_GAS_PRICE, DEVNET_DEFAULT_STARTING_BLOCK_NUMBER,
ENTRYPOINT_NOT_FOUND_ERROR_ENCODED, ETH_ERC20_CONTRACT_ADDRESS, ETH_ERC20_NAME,
ETH_ERC20_SYMBOL, STRK_ERC20_CONTRACT_ADDRESS, STRK_ERC20_NAME, STRK_ERC20_SYMBOL, USE_KZG_DA,
};
use crate::contract_class_choice::AccountContractClassChoice;
use crate::error::{ContractExecutionError, DevnetResult, Error, TransactionValidationError};
use crate::messaging::MessagingBroker;
use crate::nonzero_gas_price;
use crate::predeployed_accounts::PredeployedAccounts;
use crate::state::state_diff::StateDiff;
use crate::state::{CommittedClassStorage, CustomState, CustomStateReader, StarknetState};
use crate::traits::{AccountGenerator, Deployed, HashIdentified, HashIdentifiedMut};
use crate::transactions::{StarknetTransaction, StarknetTransactions};
use crate::utils::{custom_bouncer_config, get_versioned_constants, maybe_extract_failure_reason};
mod add_declare_transaction;
mod add_deploy_account_transaction;
mod add_invoke_transaction;
mod add_l1_handler_transaction;
mod cheats;
pub(crate) mod defaulter;
mod estimations;
pub mod events;
mod get_class_impls;
mod predeployed;
pub mod starknet_config;
mod state_update;
pub(crate) mod transaction_trace;
pub struct Starknet {
pub latest_state: StarknetState,
pub pre_confirmed_state: StarknetState,
/// Contains the diff since the last block
pre_confirmed_state_diff: StateDiff,
predeployed_accounts: PredeployedAccounts,
pub(in crate::starknet) block_context: BlockContext,
// To avoid repeating some logic related to blocks,
// having `blocks` public allows to re-use functions like `get_blocks()`.
pub(crate) blocks: StarknetBlocks,
pub transactions: StarknetTransactions,
pub config: StarknetConfig,
pub pre_confirmed_block_timestamp_shift: i64,
pub next_block_timestamp: Option<u64>,
pub next_block_gas: GasModification,
pub(crate) messaging: MessagingBroker,
rpc_contract_classes: Arc<RwLock<CommittedClassStorage>>,
cheats: Cheats,
}
impl Default for Starknet {
fn default() -> Self {
Self {
block_context: Self::init_block_context(
DEVNET_DEFAULT_L1_GAS_PRICE,
DEVNET_DEFAULT_L1_GAS_PRICE,
DEVNET_DEFAULT_L1_DATA_GAS_PRICE,
DEVNET_DEFAULT_L1_DATA_GAS_PRICE,
DEVNET_DEFAULT_L2_GAS_PRICE,
DEVNET_DEFAULT_L2_GAS_PRICE,
ETH_ERC20_CONTRACT_ADDRESS,
STRK_ERC20_CONTRACT_ADDRESS,
DEVNET_DEFAULT_CHAIN_ID,
DEVNET_DEFAULT_STARTING_BLOCK_NUMBER,
),
latest_state: Default::default(),
pre_confirmed_state: Default::default(),
pre_confirmed_state_diff: Default::default(),
predeployed_accounts: Default::default(),
blocks: Default::default(),
transactions: Default::default(),
config: Default::default(),
pre_confirmed_block_timestamp_shift: 0,
next_block_timestamp: None,
next_block_gas: GasModification {
gas_price_wei: DEVNET_DEFAULT_L1_GAS_PRICE,
data_gas_price_wei: DEVNET_DEFAULT_L1_DATA_GAS_PRICE,
gas_price_fri: DEVNET_DEFAULT_L1_GAS_PRICE,
data_gas_price_fri: DEVNET_DEFAULT_L1_DATA_GAS_PRICE,
l2_gas_price_fri: DEVNET_DEFAULT_L2_GAS_PRICE,
l2_gas_price_wei: DEVNET_DEFAULT_L2_GAS_PRICE,
},
messaging: Default::default(),
rpc_contract_classes: Default::default(),
cheats: Default::default(),
}
}
}
impl Starknet {
pub fn new(config: &StarknetConfig) -> DevnetResult<Self> {
let defaulter = StarknetDefaulter::new(config.fork_config.clone());
let rpc_contract_classes = Arc::new(RwLock::new(CommittedClassStorage::default()));
let mut state = StarknetState::new(defaulter, rpc_contract_classes.clone());
// predeclare account classes eligible for predeployment
for account_class_choice in
[AccountContractClassChoice::Cairo0, AccountContractClassChoice::Cairo1]
{
let class_wrapper = account_class_choice.get_class_wrapper()?;
state.predeclare_contract_class(
class_wrapper.class_hash,
class_wrapper.contract_class,
)?;
}
// predeclare argent account classes (not predeployable)
if config.predeclare_argent {
for (class_hash, raw_sierra) in [
(ARGENT_CONTRACT_CLASS_HASH, ARGENT_CONTRACT_SIERRA),
(ARGENT_MULTISIG_CONTRACT_CLASS_HASH, ARGENT_MULTISIG_CONTRACT_SIERRA),
] {
let contract_class =
ContractClass::Cairo1(ContractClass::cairo_1_from_sierra_json_str(raw_sierra)?);
state.predeclare_contract_class(class_hash, contract_class)?;
}
}
// deploy udc, eth erc20 and strk erc20 contracts
let eth_erc20_fee_contract = predeployed::create_erc20_at_address_extended(
ETH_ERC20_CONTRACT_ADDRESS,
config.eth_erc20_class_hash,
&config.eth_erc20_contract_class,
)?;
let strk_erc20_fee_contract = predeployed::create_erc20_at_address_extended(
STRK_ERC20_CONTRACT_ADDRESS,
config.strk_erc20_class_hash,
&config.strk_erc20_contract_class,
)?;
for udc in [predeployed::create_legacy_udc()?, predeployed::create_udc()?] {
udc.deploy(&mut state)?;
}
eth_erc20_fee_contract.deploy(&mut state)?;
initialize_erc20_at_address(
&mut state,
ETH_ERC20_CONTRACT_ADDRESS,
ETH_ERC20_NAME,
ETH_ERC20_SYMBOL,
)?;
strk_erc20_fee_contract.deploy(&mut state)?;
initialize_erc20_at_address(
&mut state,
STRK_ERC20_CONTRACT_ADDRESS,
STRK_ERC20_NAME,
STRK_ERC20_SYMBOL,
)?;
let mut predeployed_accounts = PredeployedAccounts::new(
config.seed,
config.predeployed_accounts_initial_balance.clone(),
eth_erc20_fee_contract.get_address(),
strk_erc20_fee_contract.get_address(),
);
let accounts = predeployed_accounts.generate_accounts(
config.total_accounts,
config.account_contract_class_hash,
&config.account_contract_class,
)?;
for account in accounts {
account.deploy(&mut state)?;
}
let chargeable_account = Account::new_chargeable(
eth_erc20_fee_contract.get_address(),
strk_erc20_fee_contract.get_address(),
)?;
if state
.state
.get_class_hash_at(chargeable_account.account_address.into())
.is_ok_and(|h| h.0 == Felt::ZERO)
{
chargeable_account.deploy(&mut state)?;
}
// when forking, the number of the first new block to be mined is equal to the last origin
// block (the one specified by the user) plus one.
// The parent hash of the first new block is equal to the last origin block hash.
let starting_block_number =
config.fork_config.block_number.map_or(DEVNET_DEFAULT_STARTING_BLOCK_NUMBER, |n| n + 1);
let last_block_hash = config.fork_config.block_hash;
let pre_confirmed_state_diff = state.commit_diff(starting_block_number)?;
let mut this = Self {
latest_state: Default::default(), // temporary - overwritten on genesis block creation
pre_confirmed_state: state,
pre_confirmed_state_diff,
predeployed_accounts,
block_context: Self::init_block_context(
config.gas_price_wei,
config.gas_price_fri,
config.data_gas_price_wei,
config.data_gas_price_fri,
config.l2_gas_price_wei,
config.l2_gas_price_fri,
ETH_ERC20_CONTRACT_ADDRESS,
STRK_ERC20_CONTRACT_ADDRESS,
config.chain_id,
starting_block_number,
),
blocks: StarknetBlocks::new(starting_block_number, last_block_hash),
transactions: StarknetTransactions::default(),
config: config.clone(),
pre_confirmed_block_timestamp_shift: 0,
next_block_timestamp: None,
next_block_gas: GasModification {
gas_price_wei: config.gas_price_wei,
data_gas_price_wei: config.data_gas_price_wei,
gas_price_fri: config.gas_price_fri,
data_gas_price_fri: config.data_gas_price_fri,
l2_gas_price_wei: config.l2_gas_price_wei,
l2_gas_price_fri: config.l2_gas_price_fri,
},
messaging: Default::default(),
rpc_contract_classes,
cheats: Default::default(),
};
this.restart_pre_confirmed_block()?;
// Create an empty genesis block, set start_time before if it's set
if let Some(start_time) = config.start_time {
this.set_next_block_timestamp(start_time);
};
this.create_block()?;
Ok(this)
}
pub fn get_state(&mut self) -> &mut StarknetState {
&mut self.pre_confirmed_state
}
pub fn restart(&mut self, restart_l1_to_l2_messaging: bool) -> DevnetResult<()> {
let new_messsaging_ethereum =
if restart_l1_to_l2_messaging { None } else { self.messaging.ethereum.clone() };
*self = Starknet::new(&self.config)?;
self.messaging.ethereum = new_messsaging_ethereum;
info!("Starknet Devnet restarted");
Ok(())
}
pub fn get_predeployed_accounts(&self) -> Vec<Account> {
self.predeployed_accounts.get_accounts().to_vec()
}
// Update block context
// Initialize values for new pre_confirmed block
pub(crate) fn generate_pre_confirmed_block(&mut self) -> DevnetResult<()> {
Self::advance_block_context_block_number(&mut self.block_context);
Self::set_block_context_gas(&mut self.block_context, &self.next_block_gas);
// Pre_confirmed block header gas data needs to be set
let header = &mut self.blocks.pre_confirmed_block.header.block_header_without_hash;
// Set L1 gas prices
header.l1_gas_price = GasPricePerToken {
price_in_wei: GasPrice(self.next_block_gas.gas_price_wei.get()),
price_in_fri: GasPrice(self.next_block_gas.gas_price_fri.get()),
};
// Set L1 data gas prices
header.l1_data_gas_price = GasPricePerToken {
price_in_wei: GasPrice(self.next_block_gas.data_gas_price_wei.get()),
price_in_fri: GasPrice(self.next_block_gas.data_gas_price_fri.get()),
};
// Set L2 gas prices
header.l2_gas_price = GasPricePerToken {
price_in_wei: GasPrice(self.next_block_gas.l2_gas_price_wei.get()),
price_in_fri: GasPrice(self.next_block_gas.l2_gas_price_fri.get()),
};
self.restart_pre_confirmed_block()?;
Ok(())
}
fn next_block_timestamp(&mut self) -> BlockTimestamp {
match self.next_block_timestamp {
Some(timestamp) => {
self.next_block_timestamp = None;
BlockTimestamp(timestamp)
}
None => BlockTimestamp(
(Starknet::get_unix_timestamp_as_seconds() as i64
+ self.pre_confirmed_block_timestamp_shift) as u64,
),
}
}
/// Transfer data from pre_confirmed block into new block and save it to blocks collection.
/// Generates new pre_confirmed block. Same for pre_confirmed state. Returns the new block hash.
pub(crate) fn generate_new_block_and_state(&mut self) -> DevnetResult<Felt> {
let mut new_block = self.pre_confirmed_block().clone();
// Set new block header
// Update gas prices in the block header
let header = &mut new_block.header.block_header_without_hash;
let starknet_version = header.starknet_version;
let l1_da_mode = header.l1_da_mode;
// Set L1 gas prices
header.l1_gas_price = GasPricePerToken {
price_in_fri: GasPrice(self.next_block_gas.gas_price_fri.get()),
price_in_wei: GasPrice(self.next_block_gas.gas_price_wei.get()),
};
// Set L1 data gas prices
header.l1_data_gas_price = GasPricePerToken {
price_in_fri: GasPrice(self.next_block_gas.data_gas_price_fri.get()),
price_in_wei: GasPrice(self.next_block_gas.data_gas_price_wei.get()),
};
// Set L2 gas prices
header.l2_gas_price = GasPricePerToken {
price_in_fri: GasPrice(self.next_block_gas.l2_gas_price_fri.get()),
price_in_wei: GasPrice(self.next_block_gas.l2_gas_price_wei.get()),
};
let new_block_number = self.blocks.next_latest_block_number();
new_block.set_block_hash(if self.config.lite_mode {
BlockHash::from(new_block_number.0)
} else {
new_block.generate_hash()?
});
new_block.status = BlockStatus::AcceptedOnL2;
new_block.set_block_number(new_block_number.0);
// set block timestamp and context block timestamp for contract execution
let block_timestamp = self.next_block_timestamp();
new_block.set_timestamp(block_timestamp);
Self::update_block_context_block_timestamp(&mut self.block_context, block_timestamp);
let new_block_hash = new_block.header.block_hash.0;
// update block hash for each pre_confirmed tx; block number should already be set
new_block.get_transactions().iter().for_each(|tx_hash| {
if let Some(tx) = self.transactions.get_by_hash_mut(tx_hash) {
debug_assert_eq!(tx.block_number, Some(new_block_number));
tx.block_hash = Some(new_block_hash);
tx.finality_status = TransactionFinalityStatus::AcceptedOnL2;
} else {
error!("Transaction is not present in the transactions collection");
}
});
let transaction_data: Vec<
starknet_api::block_hash::block_hash_calculator::TransactionHashingData,
> = new_block
.get_transactions()
.iter()
// filter map is used here, although in normal conditions unwrap should be safe. Every transaction hash that has been added to preconfirmed block should be present in transactions collection
// changes should be done later so this is not even possible
.filter_map(|tx_hash| self.transactions.get_by_hash(*tx_hash))
.map(|tx| tx.into())
.collect();
let thin_state_diff: ThinStateDiffImported = self.pre_confirmed_state_diff.clone().into();
let commitments = calculate_block_commitments(
&transaction_data,
&thin_state_diff,
l1_da_mode,
&starknet_version,
);
new_block.set_counts(
transaction_data.len(),
transaction_data.iter().map(|tx| tx.transaction_output.events.len()).sum(),
thin_state_diff.len(),
);
new_block.set_commitments(commitments);
// insert pre_confirmed block in the blocks collection and connect it to the state diff
self.blocks.insert(new_block, self.pre_confirmed_state_diff.clone());
self.pre_confirmed_state_diff = StateDiff::default();
// save into blocks state archive
if self.config.state_archive == StateArchiveCapacity::Full {
let clone = self.pre_confirmed_state.clone_historic();
self.blocks.save_state_at(new_block_hash, clone);
}
self.generate_pre_confirmed_block()?;
// for every new block we need to clone pre_confirmed state into state
self.latest_state = self.pre_confirmed_state.clone_historic();
Ok(new_block_hash)
}
/// Commits the changes since the last commit. Use it to commit the changes generated by the
/// last tx. Updates the `pre_confirmed_state_diff` to accumulate the changes since the last
/// block. Check `StarknetState::commit_diff` for more info.
pub fn commit_diff(&mut self) -> DevnetResult<StateDiff> {
let next_block_number = self.blocks.next_latest_block_number();
let state_diff = self.pre_confirmed_state.commit_diff(next_block_number.0)?;
self.pre_confirmed_state_diff.extend(&state_diff);
Ok(state_diff)
}
/// Handles succeeded and reverted transactions. The tx is stored and potentially dumped. A new
/// block is generated in block-generation-on-transaction mode.
pub(crate) fn handle_accepted_transaction(
&mut self,
transaction: TransactionWithHash,
tx_info: TransactionExecutionInfo,
) -> DevnetResult<()> {
let state_diff = self.commit_diff()?;
let transaction_hash = transaction.get_transaction_hash();
let gas_vector_computation_mode = transaction.transaction.gas_vector_computation_mode();
let trace = create_trace(
&mut self.pre_confirmed_state.state,
transaction.get_type(),
&tx_info,
state_diff.into(),
self.block_context.versioned_constants(),
&gas_vector_computation_mode,
)?;
let transaction_to_add = StarknetTransaction::pre_confirm(
&transaction,
tx_info,
trace,
self.blocks.pre_confirmed_block.block_number(),
);
// add accepted transaction to pre_confirmed block
self.blocks.pre_confirmed_block.add_transaction(*transaction_hash);
self.transactions.insert(transaction_hash, transaction_to_add);
// create new block from pre_confirmed one, only in block-generation-on-transaction mode
if !self.config.uses_pre_confirmed_block() {
self.generate_new_block_and_state()?;
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
/// Create a BlockContext based on BlockContext::create_for_testing()
fn init_block_context(
gas_price_wei: NonZeroU128,
gas_price_fri: NonZeroU128,
data_gas_price_wei: NonZeroU128,
data_gas_price_fri: NonZeroU128,
l2_gas_price_wei: NonZeroU128,
l2_gas_price_fri: NonZeroU128,
eth_fee_token_address: Felt,
strk_fee_token_address: Felt,
chain_id: ChainId,
block_number: u64,
) -> BlockContext {
let block_info = BlockInfo {
block_number: BlockNumber(block_number),
block_timestamp: BlockTimestamp(0),
sequencer_address: starknet_api::contract_address!("0x1000"),
gas_prices: GasPrices {
eth_gas_prices: GasPriceVector {
l1_gas_price: nonzero_gas_price!(gas_price_wei),
l1_data_gas_price: nonzero_gas_price!(data_gas_price_wei),
l2_gas_price: nonzero_gas_price!(l2_gas_price_wei),
},
strk_gas_prices: GasPriceVector {
l1_gas_price: nonzero_gas_price!(gas_price_fri),
l1_data_gas_price: nonzero_gas_price!(data_gas_price_fri),
l2_gas_price: nonzero_gas_price!(l2_gas_price_fri),
},
},
use_kzg_da: USE_KZG_DA,
};
let chain_info = ChainInfo {
chain_id: chain_id.into(),
fee_token_addresses: blockifier::context::FeeTokenAddresses {
eth_fee_token_address: starknet_api::contract_address!(
eth_fee_token_address.to_hex_string().as_str()
),
strk_fee_token_address: starknet_api::contract_address!(
strk_fee_token_address.to_hex_string().as_str()
),
},
is_l3: false,
};
BlockContext::new(
block_info,
chain_info,
get_versioned_constants(),
custom_bouncer_config(),
)
}
/// Update block context block_number with the next one
/// # Arguments
/// * `block_context` - BlockContext to be updated
fn advance_block_context_block_number(block_context: &mut BlockContext) {
let mut block_info = block_context.block_info().clone();
block_info.block_number = block_info.block_number.next().unwrap_or_default();
// TODO: update block_context via preferred method in the documentation
*block_context = BlockContext::new(
block_info,
block_context.chain_info().clone(),
get_versioned_constants(),
custom_bouncer_config(),
);
}
fn set_block_number(&mut self, block_number: u64) {
self.blocks.pre_confirmed_block.set_block_number(block_number);
let mut block_info = self.block_context.block_info().clone();
block_info.block_number.0 = block_number;
// TODO: update block_context via preferred method in the documentation
self.block_context = BlockContext::new(
block_info,
self.block_context.chain_info().clone(),
get_versioned_constants(),
custom_bouncer_config(),
);
}
fn set_block_context_gas(block_context: &mut BlockContext, gas_modification: &GasModification) {
let mut block_info = block_context.block_info().clone();
// Block info gas needs to be set here
block_info.gas_prices = GasPrices {
eth_gas_prices: GasPriceVector {
l1_gas_price: nonzero_gas_price!(gas_modification.gas_price_wei),
l1_data_gas_price: nonzero_gas_price!(gas_modification.data_gas_price_wei),
l2_gas_price: nonzero_gas_price!(gas_modification.l2_gas_price_wei),
},
strk_gas_prices: GasPriceVector {
l1_gas_price: nonzero_gas_price!(gas_modification.gas_price_fri),
l1_data_gas_price: nonzero_gas_price!(gas_modification.data_gas_price_fri),
l2_gas_price: nonzero_gas_price!(gas_modification.l2_gas_price_fri),
},
};
// TODO: update block_context via preferred method in the documentation
*block_context = BlockContext::new(
block_info,
block_context.chain_info().clone(),
get_versioned_constants(),
custom_bouncer_config(),
);
}
fn update_block_context_block_timestamp(
block_context: &mut BlockContext,
block_timestamp: BlockTimestamp,
) {
let mut block_info = block_context.block_info().clone();
block_info.block_timestamp = block_timestamp;
// TODO: update block_context via preferred method in the documentation
*block_context = BlockContext::new(
block_info,
block_context.chain_info().clone(),
get_versioned_constants(),
custom_bouncer_config(),
);
}
fn pre_confirmed_block(&self) -> &StarknetBlock {
&self.blocks.pre_confirmed_block
}
/// Restarts pre-confirmed block with information from block_context
pub(crate) fn restart_pre_confirmed_block(&mut self) -> DevnetResult<()> {
let mut block = StarknetBlock::create_pre_confirmed_block();
let header = &mut block.header.block_header_without_hash;
header.block_number = self.block_context.block_info().block_number;
let gas_prices = &self.block_context.block_info().gas_prices;
header.l1_gas_price = GasPricePerToken {
price_in_fri: gas_prices.l1_gas_price(&FeeType::Strk).get(),
price_in_wei: gas_prices.l1_gas_price(&FeeType::Eth).get(),
};
header.l1_data_gas_price = GasPricePerToken {
price_in_fri: gas_prices.l1_data_gas_price(&FeeType::Strk).get(),
price_in_wei: gas_prices.l1_data_gas_price(&FeeType::Eth).get(),
};
header.l2_gas_price = GasPricePerToken {
price_in_fri: gas_prices.l2_gas_price(&FeeType::Strk).get(),
price_in_wei: gas_prices.l2_gas_price(&FeeType::Eth).get(),
};
header.sequencer =
SequencerContractAddress(self.block_context.block_info().sequencer_address);
block.set_timestamp(self.block_context.block_info().block_timestamp);
self.blocks.pre_confirmed_block = block;
Ok(())
}
fn get_mut_state_at(&mut self, block_id: &CustomBlockId) -> DevnetResult<&mut StarknetState> {
match block_id {
CustomBlockId::Tag(CustomBlockTag::Latest) => Ok(&mut self.latest_state),
CustomBlockId::Tag(CustomBlockTag::PreConfirmed) => Ok(&mut self.pre_confirmed_state),
_ => {
let block = self.get_block(block_id)?;
let block_hash = block.block_hash();
if self.blocks.last_block_hash == Some(block_hash) {
return Ok(&mut self.latest_state);
}
if self.config.state_archive == StateArchiveCapacity::None {
return Err(Error::NoStateAtBlock { block_id: *block_id });
}
let state = self
.blocks
.hash_to_state
.get_mut(&block_hash)
.ok_or(Error::NoStateAtBlock { block_id: *block_id })?;
Ok(state)
}
}
}
pub fn get_class_hash_at(
&mut self,
block_id: &CustomBlockId,
contract_address: ContractAddress,
) -> DevnetResult<ClassHash> {
get_class_impls::get_class_hash_at_impl(self, block_id, contract_address)
}
pub fn get_class(
&self,
block_id: &CustomBlockId,
class_hash: ClassHash,
) -> DevnetResult<ContractClass> {
get_class_impls::get_class_impl(self, block_id, class_hash)
}
pub fn get_class_at(
&mut self,
block_id: &CustomBlockId,
contract_address: ContractAddress,
) -> DevnetResult<ContractClass> {
get_class_impls::get_class_at_impl(self, block_id, contract_address)
}
pub fn get_compiled_casm(&self, class_hash: ClassHash) -> DevnetResult<CasmContractClass> {
get_class_impls::get_compiled_casm_impl(self, class_hash)
}
pub fn call(
&mut self,
block_id: &CustomBlockId,
contract_address: Felt,
entrypoint_selector: Felt,
calldata: Vec<Felt>,
) -> DevnetResult<Vec<Felt>> {
let block_context = Arc::new(self.block_context.clone());
let state = self.get_mut_state_at(block_id)?;
state.assert_contract_deployed(ContractAddress::new(contract_address)?)?;
let storage_address = contract_address.try_into()?;
let class_hash = state.get_class_hash_at(storage_address)?;
let mut initial_gas =
block_context.versioned_constants().sierra_gas_limit(&ExecutionMode::Execute);
let call = blockifier::execution::entry_point::CallEntryPoint {
calldata: starknet_api::transaction::fields::Calldata(Arc::new(calldata.clone())),
storage_address: contract_address.try_into()?,
entry_point_selector: starknet_api::core::EntryPointSelector(entrypoint_selector),
initial_gas: initial_gas.0,
class_hash: Some(class_hash),
..Default::default()
};
let mut execution_context =
blockifier::execution::entry_point::EntryPointExecutionContext::new(
Arc::new(TransactionContext {
block_context: block_context.clone(),
tx_info: blockifier::transaction::objects::TransactionInfo::Deprecated(
blockifier::transaction::objects::DeprecatedTransactionInfo::default(),
),
}),
blockifier::execution::common_hints::ExecutionMode::Execute,
false,
blockifier::execution::entry_point::SierraGasRevertTracker::new(initial_gas),
);
let mut transactional_state = CachedState::create_transactional(&mut state.state);
let res = call
.execute(&mut transactional_state, &mut execution_context, &mut initial_gas.0)
.map_err(|error| {
Error::ContractExecutionError(
TransactionExecutionError::ExecutionError {
error: Box::new(error),
class_hash,
storage_address,
selector: starknet_api::core::EntryPointSelector(entrypoint_selector),
}
.into(),
)
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | true |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/transaction_trace.rs | crates/starknet-devnet-core/src/starknet/transaction_trace.rs | use blockifier::blockifier_versioned_constants::VersionedConstants;
use blockifier::execution::call_info::CallInfo;
use blockifier::execution::stack_trace::ErrorStack;
use blockifier::state::cached_state::CachedState;
use blockifier::state::state_api::StateReader;
use blockifier::transaction::objects::TransactionExecutionInfo;
use starknet_api::transaction::fields::GasVectorComputationMode;
use starknet_types::rpc::state::ThinStateDiff;
use starknet_types::rpc::transaction_receipt::ExecutionResources;
use starknet_types::rpc::transactions::{
DeclareTransactionTrace, DeployAccountTransactionTrace, ExecutionInvocation,
FunctionInvocation, InvokeTransactionTrace, L1HandlerTransactionTrace, TransactionTrace,
TransactionType,
};
use crate::error::{DevnetResult, Error};
fn get_execute_call_info<S: StateReader>(
state: &mut CachedState<S>,
execution_info: &TransactionExecutionInfo,
versioned_constants: &VersionedConstants,
gas_vector_computation_mode: &GasVectorComputationMode,
) -> DevnetResult<ExecutionInvocation> {
Ok(match &execution_info.execute_call_info {
Some(call_info) => match call_info.execution.failed {
false => ExecutionInvocation::Succeeded(FunctionInvocation::try_from_call_info(
call_info,
state,
versioned_constants,
gas_vector_computation_mode,
)?),
true => ExecutionInvocation::Reverted(starknet_types::rpc::transactions::Reversion {
revert_reason: execution_info
.revert_error
.as_ref()
.unwrap_or(&ErrorStack::default().into())
.to_string(),
}),
},
None => match &execution_info.revert_error {
Some(revert_reason) => {
ExecutionInvocation::Reverted(starknet_types::rpc::transactions::Reversion {
revert_reason: revert_reason.to_string(),
})
}
None => {
return Err(Error::UnexpectedInternalError {
msg: "Simulation contains neither call_info nor revert_error".into(),
});
}
},
})
}
fn get_call_info_invocation<S: StateReader>(
state: &mut CachedState<S>,
call_info_invocation: &Option<CallInfo>,
versioned_constants: &VersionedConstants,
gas_vector_computation_mode: &GasVectorComputationMode,
) -> DevnetResult<Option<FunctionInvocation>> {
Ok(if let Some(call_info) = call_info_invocation {
Some(FunctionInvocation::try_from_call_info(
call_info,
state,
versioned_constants,
gas_vector_computation_mode,
)?)
} else {
None
})
}
pub(crate) fn create_trace<S: StateReader>(
state: &mut CachedState<S>,
tx_type: TransactionType,
execution_info: &TransactionExecutionInfo,
state_diff: ThinStateDiff,
versioned_constants: &VersionedConstants,
gas_vector_computation_mode: &GasVectorComputationMode,
) -> DevnetResult<TransactionTrace> {
let state_diff = Some(state_diff);
let validate_invocation = get_call_info_invocation(
state,
&execution_info.validate_call_info,
versioned_constants,
gas_vector_computation_mode,
)?;
let execution_resources = ExecutionResources::from(execution_info);
let fee_transfer_invocation = get_call_info_invocation(
state,
&execution_info.fee_transfer_call_info,
versioned_constants,
gas_vector_computation_mode,
)?;
match tx_type {
TransactionType::Declare => Ok(TransactionTrace::Declare(DeclareTransactionTrace {
validate_invocation,
fee_transfer_invocation,
state_diff,
execution_resources,
})),
TransactionType::DeployAccount => {
Ok(TransactionTrace::DeployAccount(DeployAccountTransactionTrace {
validate_invocation,
constructor_invocation: get_call_info_invocation(
state,
&execution_info.execute_call_info,
versioned_constants,
gas_vector_computation_mode,
)?,
fee_transfer_invocation,
state_diff,
execution_resources,
}))
}
TransactionType::Invoke => Ok(TransactionTrace::Invoke(InvokeTransactionTrace {
validate_invocation,
execute_invocation: get_execute_call_info(
state,
execution_info,
versioned_constants,
gas_vector_computation_mode,
)?,
fee_transfer_invocation,
state_diff,
execution_resources,
})),
TransactionType::L1Handler => Ok(TransactionTrace::L1Handler(L1HandlerTransactionTrace {
function_invocation: get_execute_call_info(
state,
execution_info,
versioned_constants,
gas_vector_computation_mode,
)?,
state_diff,
execution_resources,
})),
_ => Err(Error::UnsupportedTransactionType),
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/state_update.rs | crates/starknet-devnet-core/src/starknet/state_update.rs | use starknet_types::rpc::block::BlockId;
use starknet_types::rpc::state::StateUpdate;
use super::Starknet;
use crate::error::DevnetResult;
pub fn state_update_by_block_id(
starknet: &Starknet,
block_id: &BlockId,
) -> DevnetResult<StateUpdate> {
let block = starknet.blocks.get_by_block_id(block_id).ok_or(crate::error::Error::NoBlock)?;
let state_diff =
starknet.blocks.hash_to_state_diff.get(&block.block_hash()).cloned().unwrap_or_default();
Ok(StateUpdate::new(block.block_hash(), state_diff.into()))
}
#[cfg(test)]
mod tests {
use starknet_api::contract_class::compiled_class_hash::{HashVersion, HashableCompiledClass};
use starknet_rs_core::types::{Felt, TransactionExecutionStatus};
use starknet_types::compile_sierra_contract;
use starknet_types::contract_class::ContractClass;
use starknet_types::rpc::block::{BlockId, BlockTag};
use starknet_types::rpc::state::{ClassHashPair, ContractNonce, ThinStateDiff};
use starknet_types::rpc::transactions::{
BroadcastedDeclareTransaction, TransactionFinalityStatus,
};
use starknet_types::traits::HashProducer;
use crate::starknet::tests::setup_starknet_with_no_signature_check_account;
use crate::traits::HashIdentifiedMut;
use crate::utils::test_utils::{
broadcasted_declare_tx_v3, dummy_cairo_1_contract_class, resource_bounds_with_price_1,
};
#[test]
/// This test checks that the state update is correct after a declare transaction v3.
fn correct_state_update_after_declare_transaction_v3() {
let (mut starknet, acc) = setup_starknet_with_no_signature_check_account(1e18 as u128);
let contract_class = dummy_cairo_1_contract_class();
let compiled_class_hash =
compile_sierra_contract(&contract_class).unwrap().hash(&HashVersion::V2).0;
let declare_txn = broadcasted_declare_tx_v3(
acc.account_address,
Felt::ZERO,
contract_class.clone(),
compiled_class_hash,
resource_bounds_with_price_1(0, 1000, 1e9 as u64),
);
// first execute declare v3 transaction
let (txn_hash, _) = starknet
.add_declare_transaction(BroadcastedDeclareTransaction::V3(Box::new(declare_txn)))
.unwrap();
let tx = starknet.transactions.get_by_hash_mut(&txn_hash).unwrap();
assert_eq!(tx.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_eq!(tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
let state_update = starknet.block_state_update(&BlockId::Tag(BlockTag::Latest)).unwrap();
let mut state_diff = state_update.get_state_diff().clone();
state_diff.storage_diffs.clear(); // too complicated to compare
let sierra_class_hash = ContractClass::Cairo1(contract_class).generate_hash().unwrap();
let expected_state_diff = ThinStateDiff {
declared_classes: vec![ClassHashPair {
class_hash: sierra_class_hash,
compiled_class_hash,
}],
nonces: vec![ContractNonce { contract_address: acc.account_address, nonce: Felt::ONE }],
..Default::default()
};
assert_eq!(expected_state_diff, state_diff);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/events.rs | crates/starknet-devnet-core/src/starknet/events.rs | use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::emitted_event::{EmittedEvent, Event};
use starknet_types::rpc::block::{BlockId, BlockStatus};
use starknet_types::rpc::transactions::TransactionFinalityStatus;
use super::Starknet;
use crate::error::{DevnetResult, Error};
use crate::traits::HashIdentified;
/// The method returns transaction events, based on query and if there are more results to be
/// fetched in the form of a tuple (events, has_more).
///
/// # Arguments
///
/// * `from_block` - Optional. The block id to start the query from.
/// * `to_block` - Optional. The block id to end the query at.
/// * `contract_address` - Optional. The contract address to filter the events by.
/// * `keys_filter` - Optional. The keys to filter the events by.
/// * `skip` - The number of elements to skip.
/// * `limit` - Optional. The maximum number of elements to return.
#[allow(clippy::too_many_arguments)]
pub(crate) fn get_events(
starknet: &Starknet,
from_block: Option<BlockId>,
to_block: Option<BlockId>,
contract_address: Option<ContractAddress>,
keys_filter: Option<Vec<Vec<Felt>>>,
finality_status_filter: Option<TransactionFinalityStatus>,
mut skip: u64,
limit: Option<u64>,
) -> DevnetResult<(Vec<EmittedEvent>, bool)> {
let blocks = starknet.blocks.get_blocks(from_block, to_block)?;
let mut events: Vec<EmittedEvent> = Vec::new();
let mut elements_added = 0;
// iterate over each block and get the transactions for each one
// then iterate over each transaction events and filter them
for block in blocks {
for (transaction_index, transaction_hash) in block.get_transactions().iter().enumerate() {
let transaction =
starknet.transactions.get_by_hash(*transaction_hash).ok_or(Error::NoTransaction)?;
if let Some(finality_status_filter) = finality_status_filter {
if transaction.finality_status < finality_status_filter {
continue;
}
}
// filter the events from the transaction
let filtered_transaction_events = transaction
.get_events()
.into_iter()
.enumerate()
.filter(|(_, event)| {
check_if_filter_applies_for_event(&contract_address, &keys_filter, event)
})
.skip_while(|_| {
if skip > 0 {
skip -= 1;
true
} else {
false
}
});
// produce an emitted event for each filtered transaction event
for (event_index, transaction_event) in filtered_transaction_events {
// check if there are more elements to fetch
if let Some(limit) = limit {
if elements_added == limit {
return Ok((events, true));
}
}
let (block_hash, block_number) = if block.status() == &BlockStatus::PreConfirmed {
(None, None)
} else {
(Some(block.block_hash()), Some(block.block_number()))
};
let emitted_event = EmittedEvent {
transaction_hash: *transaction_hash,
transaction_index: transaction_index as u64,
event_index: event_index as u64,
block_hash,
block_number,
keys: transaction_event.keys,
from_address: transaction_event.from_address,
data: transaction_event.data,
};
events.push(emitted_event);
elements_added += 1;
}
}
}
Ok((events, false))
}
/// This method checks if the event applies to the provided filters and returns true or false
///
/// # Arguments
/// * `address` - Optional. The address to filter the event by.
/// * `keys_filter` - Optional. The keys to filter the event by.
/// * `event` - The event to check if it applies to the filters.
pub fn check_if_filter_applies_for_event(
address: &Option<ContractAddress>,
keys_filter: &Option<Vec<Vec<Felt>>>,
event: &Event,
) -> bool {
let address_condition = match &address {
Some(from_contract_address) => event.from_address == *from_contract_address,
None => true,
};
address_condition && check_if_filter_applies_for_event_keys(keys_filter, &event.keys)
}
/// This method checks if the keys apply to the keys_filter and returns true or false
///
/// # Arguments
/// * `keys_filter` - Optional. The values to filter the keys by.
/// * `keys` - The keys to check if they apply to the filter.
fn check_if_filter_applies_for_event_keys<T>(keys_filter: &Option<Vec<Vec<T>>>, keys: &[T]) -> bool
where
T: PartialEq + Eq,
{
match &keys_filter {
Some(keys_filter) => {
for (event_key, accepted_keys) in keys.iter().zip(keys_filter) {
if !accepted_keys.is_empty() && !accepted_keys.contains(event_key) {
return false;
}
}
true
}
None => true,
}
}
#[cfg(test)]
mod tests {
use blockifier::execution::call_info::CallInfo;
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::emitted_event::Event;
use starknet_types::rpc::block::{BlockId, BlockTag};
use starknet_types::rpc::transactions::TransactionWithHash;
use super::{check_if_filter_applies_for_event, get_events};
use crate::starknet::Starknet;
use crate::starknet::events::check_if_filter_applies_for_event_keys;
use crate::starknet::starknet_config::StarknetConfig;
use crate::traits::HashIdentified;
use crate::utils::test_utils::{dummy_contract_address, dummy_declare_tx_v3_with_hash};
#[test]
fn filter_keys_with_empty_or_no_filter() {
let keys = vec![1u32];
// no filter
assert!(check_if_filter_applies_for_event_keys(&None, &keys));
// empty filter
let filter = vec![];
assert!(check_if_filter_applies_for_event_keys(&Some(filter), &keys));
// empty filter, but made of two empty filters
let filter = vec![vec![], vec![]];
assert!(check_if_filter_applies_for_event_keys(&Some(filter), &keys));
}
#[test]
fn filter_applies_to_single_key() {
// check for 1 key
let keys = vec![1u32];
// filter with 1 key and second one empty filter
let filter = vec![vec![1u32], vec![]];
assert!(check_if_filter_applies_for_event_keys(&Some(filter), &keys));
// filter with 1 key and second one value that is not amongst the keys, but will not
// evaluate, because the keys is of length 1
let filter = vec![vec![1u32], vec![2u32]];
assert!(check_if_filter_applies_for_event_keys(&Some(filter), &keys));
// filter with multiple keys, that are different from the keys, except one and second filter
// is empty
let filter = vec![vec![0u32, 1u32], vec![]];
assert!(check_if_filter_applies_for_event_keys(&Some(filter), &keys));
}
#[test]
fn filter_does_not_apply_to_single_key() {
let keys = vec![1u32];
// filter with 1 key, that is different from the keys and second one empty filter
let filter = vec![vec![0u32], vec![]];
assert!(!check_if_filter_applies_for_event_keys(&Some(filter), &keys));
// filter with multiple keys, that are different from the keys and second filter is empty
let filter = vec![vec![0u32, 2u32], vec![]];
assert!(!check_if_filter_applies_for_event_keys(&Some(filter), &keys));
}
#[test]
fn filter_applies_to_multiple_keys() {
let keys = vec![3u32, 2u32];
// both filters apply to the keys, each filter is with 1 value
let filter = vec![vec![3u32], vec![2u32]];
assert!(check_if_filter_applies_for_event_keys(&Some(filter), &keys));
// both filter apply to the keys, each filter is with multiple values
let filter = vec![vec![3u32, 1u32], vec![0u32, 2u32]];
assert!(check_if_filter_applies_for_event_keys(&Some(filter), &keys));
// first filter applies to the keys, second filter is empty
let filter = vec![vec![3u32, 1u32], vec![]];
assert!(check_if_filter_applies_for_event_keys(&Some(filter), &keys));
// first filter is empty, second filter applies to the keys
let filter = vec![vec![], vec![0u32, 2u32]];
assert!(check_if_filter_applies_for_event_keys(&Some(filter), &keys));
// both filters are empty
let filter = vec![vec![], vec![]];
assert!(check_if_filter_applies_for_event_keys(&Some(filter), &keys));
}
#[test]
fn filter_does_not_apply_to_multiple_keys() {
let keys = vec![3u32, 2u32];
// first filter applies to the keys, second filter does not
let filter = vec![vec![3u32, 1u32], vec![0u32]];
assert!(!check_if_filter_applies_for_event_keys(&Some(filter), &keys));
// first filter does not apply to the keys, second filter applies
let filter = vec![vec![0u32], vec![0u32, 2u32]];
assert!(!check_if_filter_applies_for_event_keys(&Some(filter), &keys));
// both filters do not apply to the keys
let filter = vec![vec![0u32], vec![0u32]];
assert!(!check_if_filter_applies_for_event_keys(&Some(filter), &keys));
}
#[test]
fn filter_with_address_only() {
let event = dummy_event();
// filter with address that is the same as the on in the event
let address = Some(dummy_contract_address());
assert!(check_if_filter_applies_for_event(&address, &None, &event));
// filter with address that is different from the one in the event
let address = ContractAddress::new(Felt::ZERO).unwrap();
assert!(!check_if_filter_applies_for_event(&Some(address), &None, &event));
}
#[test]
fn filter_with_keys_only() {
let event = dummy_event();
let keys_filter = vec![vec![Felt::ONE, Felt::THREE]];
assert!(!check_if_filter_applies_for_event(&None, &Some(keys_filter), &event));
let keys_filter = vec![vec![], vec![Felt::ONE, Felt::THREE]];
assert!(check_if_filter_applies_for_event(&None, &Some(keys_filter), &event));
}
#[test]
fn filter_with_address_and_keys() {
let event = dummy_event();
// filter with address correct and filter keys correct
let address = Some(dummy_contract_address());
let keys_filter = vec![vec![Felt::TWO, Felt::THREE]];
assert!(check_if_filter_applies_for_event(&address, &Some(keys_filter), &event));
// filter with incorrect address and correct filter keys
let address = Some(ContractAddress::new(Felt::ZERO).unwrap());
let keys_filter = vec![vec![Felt::TWO, Felt::THREE]];
assert!(!check_if_filter_applies_for_event(&address, &Some(keys_filter), &event));
// filter with correct address and incorrect filter keys
let address = Some(dummy_contract_address());
let keys_filter = vec![vec![Felt::ONE, Felt::THREE]];
assert!(!check_if_filter_applies_for_event(&address, &Some(keys_filter), &event));
// filter with incorrect address and incorrect filter keys
let address = Some(ContractAddress::new(Felt::ZERO).unwrap());
let keys_filter = vec![vec![Felt::ONE, Felt::THREE]];
assert!(!check_if_filter_applies_for_event(&address, &Some(keys_filter), &event));
}
#[test]
fn pagination_for_latest_block_that_has_1_transaction_with_5_events() {
let starknet = setup();
// no pagination to the latest block events
let (events, has_more) = get_events(
&starknet,
Some(BlockId::Tag(BlockTag::Latest)),
Some(BlockId::Tag(BlockTag::Latest)),
None,
None,
None,
0,
None,
)
.unwrap();
assert_eq!(events.len(), 5);
assert!(!has_more);
// limit the result to only events, should be left 2 more
let (events, has_more) = get_events(
&starknet,
Some(BlockId::Tag(BlockTag::Latest)),
Some(BlockId::Tag(BlockTag::Latest)),
None,
None,
None,
0,
Some(3),
)
.unwrap();
assert_eq!(events.len(), 3);
assert!(has_more);
// skip 3 events and return maximum 3, but the result should be 2, because the total amount
// of events for the latest block is 5
let (events, has_more) = get_events(
&starknet,
Some(BlockId::Tag(BlockTag::Latest)),
Some(BlockId::Tag(BlockTag::Latest)),
None,
None,
None,
3,
Some(3),
)
.unwrap();
assert_eq!(events.len(), 2);
assert!(!has_more);
}
#[test]
fn pagination_for_events_of_multiple_blocks() {
let starknet = setup();
// returns all events from all blocks
let (events, has_more) =
get_events(&starknet, None, None, None, None, None, 0, None).unwrap();
assert_eq!(events.len(), 15);
assert!(!has_more);
// returns all events from all blocks, skip 3, but limit the result to 10
let (events, has_more) =
get_events(&starknet, None, None, None, None, None, 3, Some(10)).unwrap();
assert_eq!(events.len(), 10);
assert!(has_more);
// returns all events from the first 2 blocks, skip 3, but limit the result to 1
let (events, has_more) =
get_events(&starknet, None, Some(BlockId::Number(2)), None, None, None, 3, Some(1))
.unwrap();
assert_eq!(events.len(), 0);
assert!(!has_more);
// returns all events from the first 2 blocks, skip 1, but limit the result to 1, it should
// return 1 event and should be more
let (events, has_more) =
get_events(&starknet, None, Some(BlockId::Number(2)), None, None, None, 1, Some(1))
.unwrap();
assert_eq!(events.len(), 1);
assert!(has_more);
}
#[test]
fn check_correct_events_being_returned() {
let starknet = setup();
// events with key 15 should be only 1 in the 5th transaction
let (events, _) = get_events(
&starknet,
None,
None,
None,
Some(vec![vec![Felt::from(15)]]),
None,
0,
None,
)
.unwrap();
assert_eq!(events.len(), 1);
assert_eq!(events[0].transaction_hash, Felt::from(104));
assert_eq!(events[0].keys.len(), 1);
assert_eq!(events[0].keys[0], Felt::from(15));
assert_eq!(events[0].data[0], Felt::from(25));
let (events, _) = get_events(
&starknet,
None,
None,
None,
Some(vec![vec![Felt::from(12)]]),
None,
0,
None,
)
.unwrap();
assert_eq!(events.len(), 4);
// start from transaction hash 101 because from the setup the first transaction has
// generated event with key 11
for (idx, event) in events.iter().enumerate() {
assert_eq!(event.transaction_hash, Felt::from(101 + idx as u128));
assert_eq!(event.keys.len(), 1);
assert_eq!(event.keys[0], Felt::from(12));
assert_eq!(event.data[0], Felt::from(22));
}
}
fn setup() -> Starknet {
// generate 5 transactions
// each transaction should have events count equal to the order of the transaction
let mut starknet = Starknet::new(&StarknetConfig::default()).unwrap();
let mut transaction = dummy_declare_tx_v3_with_hash();
for idx in 0..5 {
let txn_info = blockifier::transaction::objects::TransactionExecutionInfo {
execute_call_info: Some(dummy_call_info(idx + 1)),
..Default::default()
};
let transaction_hash = Felt::from(idx as u128 + 100);
transaction = TransactionWithHash::new(transaction_hash, transaction.transaction);
starknet.handle_accepted_transaction(transaction.clone(), txn_info).unwrap();
}
assert_eq!(
starknet.blocks.get_blocks(None, Some(BlockId::Tag(BlockTag::Latest))).unwrap().len(),
6
);
for idx in 0..5 {
starknet.transactions.get_by_hash(Felt::from(idx as u128 + 100)).unwrap();
}
starknet
}
fn dummy_call_info(events_count: usize) -> CallInfo {
let mut call_info = CallInfo::default();
// reverse the order of the events, for example: [{order: 3, event: E3}, {order: 2, event:
// E2}, {order: 1, event: E1}] so we can check that events are returned in ascending
// order based on the "order" field of the object when extracting them from
// transaction execution call info
for idx in (1..=events_count).rev() {
let event = blockifier::execution::call_info::OrderedEvent {
order: idx,
event: starknet_api::transaction::EventContent {
keys: vec![starknet_api::transaction::EventKey(Felt::from(idx as u128 + 10))],
data: starknet_api::transaction::EventData(vec![Felt::from(idx as u128 + 20)]),
},
};
call_info.execution.events.push(event);
}
call_info
}
fn dummy_event() -> Event {
Event {
from_address: dummy_contract_address(),
keys: vec![Felt::TWO, Felt::THREE],
data: vec![Felt::ONE, Felt::ONE],
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/add_declare_transaction.rs | crates/starknet-devnet-core/src/starknet/add_declare_transaction.rs | use blockifier::transaction::account_transaction::ExecutionFlags;
use blockifier::transaction::transactions::ExecutableTransaction;
use starknet_api::contract_class::compiled_class_hash::{HashVersion, HashableCompiledClass};
use starknet_types::compile_sierra_contract;
use starknet_types::contract_class::ContractClass;
use starknet_types::felt::{ClassHash, CompiledClassHash, TransactionHash};
use starknet_types::rpc::transactions::declare_transaction_v3::DeclareTransactionV3;
use starknet_types::rpc::transactions::{
BroadcastedDeclareTransaction, DeclareTransaction, Transaction, TransactionWithHash,
};
use super::starknet_config::ClassSizeConfig;
use crate::error::{DevnetResult, Error, TransactionValidationError};
use crate::starknet::Starknet;
use crate::state::CustomState;
fn check_class_size(
executable_tx: &starknet_api::executable_transaction::DeclareTransaction,
config: &ClassSizeConfig,
) -> DevnetResult<()> {
let serialized_class = serde_json::to_vec(&executable_tx.contract_class()).map_err(|e| {
Error::UnexpectedInternalError {
msg: format!("Could not determine class size via serialization: {e}"),
}
})?;
let contract_class_size = serialized_class.len() as u64;
let sierra_length = executable_tx.class_info.sierra_program_length() as u64;
let casm_length = executable_tx.class_info.bytecode_length() as u64;
tracing::info!(
"Declaring class: serialized size: {} bytes, sierra: {} felts, casm: {} felts",
contract_class_size,
sierra_length,
casm_length,
);
if contract_class_size > config.maximum_contract_class_size
|| sierra_length > config.maximum_sierra_length
|| casm_length > config.maximum_contract_bytecode_size
{
return Err(Error::ContractClassSizeIsTooLarge);
}
Ok(())
}
pub fn add_declare_transaction(
starknet: &mut Starknet,
broadcasted_declare_transaction: BroadcastedDeclareTransaction,
) -> DevnetResult<(TransactionHash, ClassHash)> {
if !broadcasted_declare_transaction.are_gas_bounds_valid() {
return Err(TransactionValidationError::InsufficientResourcesForValidate.into());
}
if broadcasted_declare_transaction.is_only_query() {
return Err(Error::UnsupportedAction {
msg: "only-query transactions are not supported".to_string(),
});
}
let executable_tx =
broadcasted_declare_transaction.create_sn_api_declare(&starknet.chain_id().to_felt())?;
check_class_size(&executable_tx, &starknet.config.class_size_config)?;
let transaction_hash = executable_tx.tx_hash.0;
let class_hash = executable_tx.class_hash().0;
let (declare_transaction, contract_class, casm_hash, sender_address) =
match broadcasted_declare_transaction {
BroadcastedDeclareTransaction::V3(ref v3) => {
let declare_transaction = Transaction::Declare(DeclareTransaction::V3(
DeclareTransactionV3::new(v3, class_hash),
));
(
declare_transaction,
v3.contract_class.clone().into(),
Some(v3.compiled_class_hash),
&v3.sender_address,
)
}
};
assert_casm_hash_is_valid(&contract_class, casm_hash)?;
let validate = !(Starknet::is_account_impersonated(
&mut starknet.pre_confirmed_state,
&starknet.cheats,
sender_address,
)?);
let transaction = TransactionWithHash::new(transaction_hash, declare_transaction);
let execution_info = blockifier::transaction::account_transaction::AccountTransaction {
tx: starknet_api::executable_transaction::AccountTransaction::Declare(executable_tx),
execution_flags: ExecutionFlags {
only_query: false,
charge_fee: true,
validate,
strict_nonce_check: true, // Starknet 0.14: declare txs do not allow nonce supersession
},
}
.execute(&mut starknet.pre_confirmed_state.state, &starknet.block_context)?;
// if tx successful, store the class
if !execution_info.is_reverted() {
let state = starknet.get_state();
state.declare_contract_class(class_hash, casm_hash, contract_class)?;
}
starknet.handle_accepted_transaction(transaction, execution_info)?;
Ok((transaction_hash, class_hash))
}
/// If cairo1, convert `contract_class` to casm, calculate its hash and assert it's equal to
/// `received_casm_hash`. If cairo0, assert no `received_casm_hash`.
fn assert_casm_hash_is_valid(
contract_class: &ContractClass,
received_casm_hash: Option<CompiledClassHash>,
) -> DevnetResult<()> {
match (contract_class, received_casm_hash) {
(ContractClass::Cairo0(_), None) => Ok(()), // if cairo0, casm_hash expected to be None
(ContractClass::Cairo1(cairo_lang_contract_class), Some(received_casm_hash)) => {
let casm = compile_sierra_contract(cairo_lang_contract_class)?;
let calculated_casm_hash = casm.hash(&HashVersion::V2).0;
if calculated_casm_hash == received_casm_hash {
Ok(())
} else {
Err(Error::CompiledClassHashMismatch)
}
}
unexpected => Err(Error::UnexpectedInternalError {
msg: format!("Unexpected class and casm combination: {unexpected:?}"),
}),
}
}
#[cfg(test)]
mod tests {
use starknet_api::data_availability::DataAvailabilityMode;
use starknet_rs_core::types::{Felt, TransactionExecutionStatus};
use starknet_types::constants::QUERY_VERSION_OFFSET;
use starknet_types::contract_class::ContractClass;
use starknet_types::rpc::transactions::broadcasted_declare_transaction_v3::BroadcastedDeclareTransactionV3;
use starknet_types::rpc::transactions::{
BroadcastedDeclareTransaction, BroadcastedTransactionCommonV3, ResourceBoundsWrapper,
TransactionFinalityStatus,
};
use starknet_types::traits::HashProducer;
use crate::error::{Error, TransactionValidationError};
use crate::starknet::Starknet;
use crate::starknet::starknet_config::BlockGenerationOn;
use crate::starknet::tests::setup_starknet_with_no_signature_check_account;
use crate::state::{BlockNumberOrPreConfirmed, CustomStateReader};
use crate::traits::HashIdentifiedMut;
use crate::utils::test_utils::{
broadcasted_declare_tx_v3_of_dummy_class, dummy_cairo_1_contract_class,
dummy_contract_address, dummy_felt, resource_bounds_with_price_1,
};
#[test]
fn declare_transaction_v3_with_query_version_should_return_an_error() {
let declare_tx = BroadcastedDeclareTransactionV3 {
common: BroadcastedTransactionCommonV3 {
version: Felt::THREE + QUERY_VERSION_OFFSET,
signature: vec![],
nonce: dummy_felt(),
resource_bounds: resource_bounds_with_price_1(1, 1, 1),
tip: Default::default(),
paymaster_data: vec![],
nonce_data_availability_mode: DataAvailabilityMode::L1,
fee_data_availability_mode: DataAvailabilityMode::L1,
},
contract_class: dummy_cairo_1_contract_class(),
sender_address: dummy_contract_address(),
compiled_class_hash: dummy_felt(),
account_deployment_data: vec![],
};
let result = Starknet::default()
.add_declare_transaction(BroadcastedDeclareTransaction::V3(Box::new(declare_tx)));
match result {
Err(Error::UnsupportedAction { msg }) => {
assert_eq!(msg, "only-query transactions are not supported")
}
other => panic!("Unexpected result: {other:?}"),
};
}
#[test]
fn declare_transaction_v3_with_zero_gas_bounds_should_return_an_error() {
let declare_tx = BroadcastedDeclareTransactionV3 {
common: BroadcastedTransactionCommonV3 {
version: Felt::THREE + QUERY_VERSION_OFFSET,
signature: vec![],
nonce: dummy_felt(),
resource_bounds: ResourceBoundsWrapper::new(0, 0, 0, 0, 0, 0),
tip: Default::default(),
paymaster_data: vec![],
nonce_data_availability_mode: DataAvailabilityMode::L1,
fee_data_availability_mode: DataAvailabilityMode::L1,
},
contract_class: dummy_cairo_1_contract_class(),
sender_address: dummy_contract_address(),
compiled_class_hash: dummy_felt(),
account_deployment_data: vec![],
};
let result = Starknet::default()
.add_declare_transaction(BroadcastedDeclareTransaction::V3(Box::new(declare_tx)));
match result {
Err(Error::TransactionValidationError(
TransactionValidationError::InsufficientResourcesForValidate,
)) => {}
other => panic!("Unexpected result: {other:?}"),
}
}
#[test]
fn add_declare_v3_transaction_successful_execution() {
let (mut starknet, sender) = setup_starknet_with_no_signature_check_account(1e18 as u128);
let declare_tx = broadcasted_declare_tx_v3_of_dummy_class(
sender.account_address,
Felt::ZERO,
resource_bounds_with_price_1(0, 1000, 1e9 as u64),
);
let (tx_hash, class_hash) =
starknet.add_declare_transaction(declare_tx.clone().into()).unwrap();
let tx = starknet.transactions.get_by_hash_mut(&tx_hash).unwrap();
// check if generated class hash is expected one
assert_eq!(
class_hash,
ContractClass::Cairo1(declare_tx.contract_class).generate_hash().unwrap()
);
// check if txn is with status accepted
assert_eq!(tx.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_eq!(tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
starknet
.rpc_contract_classes
.read()
.get_class(&class_hash, &BlockNumberOrPreConfirmed::Number(tx.block_number.unwrap().0))
.unwrap();
}
#[test]
fn add_declare_v3_transaction_should_return_an_error_due_to_low_gas_bounds() {
let (mut starknet, sender) = setup_starknet_with_no_signature_check_account(20000);
let declare_tx = broadcasted_declare_tx_v3_of_dummy_class(
sender.account_address,
Felt::ZERO,
resource_bounds_with_price_1(0, 1, 1),
);
match starknet.add_declare_transaction(declare_tx.into()) {
Err(Error::TransactionValidationError(
TransactionValidationError::InsufficientResourcesForValidate,
)) => {}
other => panic!("Unexpected result: {other:?}"),
}
}
#[test]
fn add_declare_v3_transaction_should_return_an_error_due_to_not_enough_balance_on_account() {
let (mut starknet, sender) = setup_starknet_with_no_signature_check_account(1);
let declare_tx = broadcasted_declare_tx_v3_of_dummy_class(
sender.account_address,
Felt::ZERO,
resource_bounds_with_price_1(0, 1000, 1e9 as u64),
);
match starknet.add_declare_transaction(declare_tx.into()).unwrap_err() {
Error::TransactionValidationError(
TransactionValidationError::InsufficientAccountBalance,
) => {}
err => panic!("Wrong error type received {:?}", err),
}
}
#[test]
fn declare_v3_transaction_successful_storage_change() {
let (mut starknet, sender) = setup_starknet_with_no_signature_check_account(1e18 as u128);
let declare_tx = broadcasted_declare_tx_v3_of_dummy_class(
sender.account_address,
Felt::ZERO,
resource_bounds_with_price_1(0, 1000, 1e9 as u64),
);
// check if contract is not declared
let expected_class_hash =
ContractClass::Cairo1(declare_tx.contract_class.clone()).generate_hash().unwrap();
assert!(!starknet.pre_confirmed_state.is_contract_declared(expected_class_hash));
let (tx_hash, class_hash) = starknet.add_declare_transaction(declare_tx.into()).unwrap();
let tx = starknet.transactions.get_by_hash_mut(&tx_hash).unwrap();
// check if txn is with status accepted
assert_eq!(tx.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_eq!(tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
// check if contract is declared
assert!(starknet.pre_confirmed_state.is_contract_declared(class_hash));
}
#[test]
fn declare_tx_should_fail_if_nonce_repeated() {
let (mut starknet, sender) = setup_starknet_with_no_signature_check_account(1e18 as u128);
let tx_nonce = Felt::ZERO;
let declare_tx = broadcasted_declare_tx_v3_of_dummy_class(
sender.account_address,
tx_nonce,
resource_bounds_with_price_1(0, 1000, 1e9 as u64),
);
// check if contract is not declared
let expected_class_hash =
ContractClass::Cairo1(declare_tx.contract_class.clone()).generate_hash().unwrap();
assert!(!starknet.pre_confirmed_state.is_contract_declared(expected_class_hash));
let (tx_hash, class_hash) =
starknet.add_declare_transaction(declare_tx.clone().into()).unwrap();
let tx = starknet.transactions.get_by_hash_mut(&tx_hash).unwrap();
// check if txn is with status accepted
assert_eq!(tx.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_eq!(tx.execution_result.status(), TransactionExecutionStatus::Succeeded);
// check if contract is declared
assert!(starknet.pre_confirmed_state.is_contract_declared(class_hash));
match starknet.add_declare_transaction(declare_tx.into()) {
Err(Error::TransactionValidationError(
TransactionValidationError::InvalidTransactionNonce {
address,
account_nonce,
incoming_tx_nonce,
},
)) => assert_eq!(
(address, account_nonce.0, incoming_tx_nonce.0),
(sender.account_address, Felt::ONE, tx_nonce)
),
other => panic!("Unexpected result: {other:?}"),
};
assert!(starknet.pre_confirmed_state.is_contract_declared(class_hash));
}
#[test]
fn declare_tx_should_fail_if_nonce_higher_than_expected_in_block_on_tx_mode() {
declare_tx_should_fail_if_nonce_higher_than_expected(BlockGenerationOn::Transaction);
}
#[test]
fn declare_tx_should_fail_if_nonce_higher_than_expected_in_block_on_demand_mode() {
declare_tx_should_fail_if_nonce_higher_than_expected(BlockGenerationOn::Demand);
}
#[test]
fn declaration_success_should_depend_on_class_size_limit() {
let (mut starknet, sender) = setup_starknet_with_no_signature_check_account(1e18 as u128);
let declare_tx = broadcasted_declare_tx_v3_of_dummy_class(
sender.account_address,
Felt::ZERO,
resource_bounds_with_price_1(0, 1000, 1e9 as u64),
);
let old_limit = starknet.config.class_size_config.maximum_contract_class_size;
// Should fail
// Ideally would be set to (size - 1), but serialization is not the same for the class used
// here and the one in `add_declare_transaction`.
starknet.config.class_size_config.maximum_contract_class_size = 1;
match starknet.add_declare_transaction(declare_tx.clone().into()) {
Err(Error::ContractClassSizeIsTooLarge) => (),
other => panic!("Unexpected declaration result: {other:?}"),
};
// Should pass
starknet.config.class_size_config.maximum_contract_class_size = old_limit;
let (_tx_hash, class_hash) = starknet.add_declare_transaction(declare_tx.into()).unwrap();
assert!(starknet.pre_confirmed_state.is_contract_declared(class_hash));
}
#[test]
fn declaration_success_should_depend_on_bytecode_size_limit() {
let (mut starknet, sender) = setup_starknet_with_no_signature_check_account(1e18 as u128);
let declare_tx = broadcasted_declare_tx_v3_of_dummy_class(
sender.account_address,
Felt::ZERO,
resource_bounds_with_price_1(0, 1000, 1e9 as u64),
);
let old_limit = starknet.config.class_size_config.maximum_contract_bytecode_size;
// Should fail
// Ideally would be set to (size - 1), but serialization is not the same for the class used
// here and the one in `add_declare_transaction`.
starknet.config.class_size_config.maximum_contract_bytecode_size = 1;
match starknet.add_declare_transaction(declare_tx.clone().into()) {
Err(Error::ContractClassSizeIsTooLarge) => (),
other => panic!("Unexpected declaration result: {other:?}"),
};
// Should pass
starknet.config.class_size_config.maximum_contract_bytecode_size = old_limit;
let (_tx_hash, class_hash) = starknet.add_declare_transaction(declare_tx.into()).unwrap();
assert!(starknet.pre_confirmed_state.is_contract_declared(class_hash));
}
#[test]
fn declaration_success_should_depend_on_sierra_length_limit() {
let (mut starknet, sender) = setup_starknet_with_no_signature_check_account(1e18 as u128);
let declare_tx = broadcasted_declare_tx_v3_of_dummy_class(
sender.account_address,
Felt::ZERO,
resource_bounds_with_price_1(0, 1000, 1e9 as u64),
);
let sierra_length = declare_tx.contract_class.sierra_program.len() as u64;
// Should fail
starknet.config.class_size_config.maximum_sierra_length = sierra_length - 1;
match starknet.add_declare_transaction(declare_tx.clone().into()) {
Err(Error::ContractClassSizeIsTooLarge) => (),
other => panic!("Unexpected declaration result: {other:?}"),
};
// Should pass
starknet.config.class_size_config.maximum_sierra_length = sierra_length;
let (_tx_hash, class_hash) = starknet.add_declare_transaction(declare_tx.into()).unwrap();
assert!(starknet.pre_confirmed_state.is_contract_declared(class_hash));
}
fn declare_tx_should_fail_if_nonce_higher_than_expected(
block_generation_mode: BlockGenerationOn,
) {
let (mut starknet, sender) = setup_starknet_with_no_signature_check_account(1e18 as u128);
starknet.config.block_generation_on = block_generation_mode;
let tx_nonce = Felt::ONE; // nonce too high
let declare_tx = broadcasted_declare_tx_v3_of_dummy_class(
sender.account_address,
tx_nonce,
resource_bounds_with_price_1(0, 1000, 1e9 as u64),
);
// check if contract is not declared
let expected_class_hash =
ContractClass::Cairo1(declare_tx.contract_class.clone()).generate_hash().unwrap();
assert!(!starknet.pre_confirmed_state.is_contract_declared(expected_class_hash));
match starknet.add_declare_transaction(declare_tx.into()) {
Err(Error::TransactionValidationError(
TransactionValidationError::InvalidTransactionNonce {
address,
account_nonce,
incoming_tx_nonce,
},
)) => assert_eq!(
(address, account_nonce.0, incoming_tx_nonce.0),
(sender.account_address, Felt::ZERO, tx_nonce)
),
other => panic!("Unexpected result: {other:?}"),
};
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/starknet/add_deploy_account_transaction.rs | crates/starknet-devnet-core/src/starknet/add_deploy_account_transaction.rs | use blockifier::transaction::account_transaction::ExecutionFlags;
use blockifier::transaction::transactions::ExecutableTransaction;
use starknet_types::contract_address::ContractAddress;
use starknet_types::felt::TransactionHash;
use starknet_types::rpc::transactions::deploy_account_transaction_v3::DeployAccountTransactionV3;
use starknet_types::rpc::transactions::{
BroadcastedDeployAccountTransaction, DeployAccountTransaction, Transaction, TransactionWithHash,
};
use super::Starknet;
use crate::error::{DevnetResult, Error, TransactionValidationError};
use crate::state::CustomStateReader;
pub fn add_deploy_account_transaction(
starknet: &mut Starknet,
broadcasted_deploy_account_transaction: BroadcastedDeployAccountTransaction,
) -> DevnetResult<(TransactionHash, ContractAddress)> {
if !broadcasted_deploy_account_transaction.are_gas_bounds_valid() {
return Err(TransactionValidationError::InsufficientResourcesForValidate.into());
}
if broadcasted_deploy_account_transaction.is_only_query() {
return Err(Error::UnsupportedAction {
msg: "only-query transactions are not supported".to_string(),
});
}
let executable_deploy_account_tx = broadcasted_deploy_account_transaction
.create_sn_api_deploy_account(&starknet.chain_id().to_felt())?;
let address = executable_deploy_account_tx.contract_address.into();
let (class_hash, deploy_account_transaction) = match broadcasted_deploy_account_transaction {
BroadcastedDeployAccountTransaction::V3(ref v3) => {
let deploy_account_transaction =
Transaction::DeployAccount(DeployAccountTransaction::V3(Box::new(
DeployAccountTransactionV3::new(v3, address),
)));
(v3.class_hash, deploy_account_transaction)
}
};
if !starknet.pre_confirmed_state.is_contract_declared(class_hash) {
return Err(Error::StateError(crate::error::StateError::NoneClassHash(class_hash)));
}
let transaction_hash = executable_deploy_account_tx.tx_hash.0;
let transaction = TransactionWithHash::new(transaction_hash, deploy_account_transaction);
let strict_nonce_check = broadcasted_deploy_account_transaction
.requires_strict_nonce_check(starknet.config.uses_pre_confirmed_block());
let execution_info = blockifier::transaction::account_transaction::AccountTransaction {
tx: starknet_api::executable_transaction::AccountTransaction::DeployAccount(
executable_deploy_account_tx,
),
execution_flags: ExecutionFlags {
only_query: false,
charge_fee: true,
validate: true,
strict_nonce_check,
},
}
.execute(&mut starknet.pre_confirmed_state.state, &starknet.block_context)?;
starknet.handle_accepted_transaction(transaction, execution_info)?;
Ok((transaction_hash, address))
}
#[cfg(test)]
mod tests {
use blockifier::state::state_api::{State, StateReader};
use nonzero_ext::nonzero;
use starknet_api::transaction::fields::Tip;
use starknet_rs_core::types::{Felt, TransactionExecutionStatus};
use starknet_types::constants::QUERY_VERSION_OFFSET;
use starknet_types::contract_address::ContractAddress;
use starknet_types::felt::ClassHash;
use starknet_types::rpc::block::{BlockId, BlockTag};
use starknet_types::rpc::transactions::broadcasted_deploy_account_transaction_v3::BroadcastedDeployAccountTransactionV3;
use starknet_types::rpc::transactions::{
BroadcastedDeployAccountTransaction, BroadcastedTransactionCommonV3, ResourceBoundsWrapper,
TransactionFinalityStatus,
};
use starknet_types::traits::HashProducer;
use crate::constants::{
DEVNET_DEFAULT_CHAIN_ID, DEVNET_DEFAULT_STARTING_BLOCK_NUMBER, ETH_ERC20_CONTRACT_ADDRESS,
STRK_ERC20_CONTRACT_ADDRESS,
};
use crate::error::{Error, TransactionValidationError};
use crate::starknet::{Starknet, predeployed};
use crate::state::CustomState;
use crate::traits::{Deployed, HashIdentifiedMut};
use crate::utils::get_storage_var_address;
use crate::utils::test_utils::cairo_0_account_without_validations;
const GAS_PRICE: u128 = 1_u128;
fn test_deploy_account_transaction_v3(
class_hash: ClassHash,
nonce: u128,
l1_gas_amount: u64,
l1_data_gas_amount: u64,
l2_gas_amount: u64,
) -> BroadcastedDeployAccountTransactionV3 {
BroadcastedDeployAccountTransactionV3 {
common: BroadcastedTransactionCommonV3 {
version: Felt::THREE,
signature: vec![],
nonce: Felt::from(nonce),
resource_bounds: ResourceBoundsWrapper::new(
l1_gas_amount,
GAS_PRICE,
l1_data_gas_amount,
GAS_PRICE,
l2_gas_amount,
GAS_PRICE,
),
tip: Tip(0),
paymaster_data: vec![],
nonce_data_availability_mode:
starknet_api::data_availability::DataAvailabilityMode::L1,
fee_data_availability_mode:
starknet_api::data_availability::DataAvailabilityMode::L1,
},
contract_address_salt: 0.into(),
constructor_calldata: vec![],
class_hash,
}
}
#[test]
fn account_deploy_transaction_v3_with_query_version_should_return_an_error() {
let mut deploy_account_transaction =
test_deploy_account_transaction_v3(Felt::default(), 0, 10, 0, 0);
deploy_account_transaction.common.version = Felt::THREE + QUERY_VERSION_OFFSET;
let result = Starknet::default().add_deploy_account_transaction(
BroadcastedDeployAccountTransaction::V3(deploy_account_transaction),
);
match result {
Err(crate::error::Error::UnsupportedAction { msg }) => {
assert_eq!(msg, "only-query transactions are not supported")
}
other => panic!("Unexpected result: {other:?}"),
};
}
#[test]
fn deploy_account_transaction_v3_with_zero_gas_bounds_should_return_an_error() {
let (mut starknet, account_class_hash) = setup();
let tx = test_deploy_account_transaction_v3(account_class_hash, 0, 0, 0, 0);
match starknet.add_deploy_account_transaction(BroadcastedDeployAccountTransaction::V3(tx)) {
Err(Error::TransactionValidationError(
TransactionValidationError::InsufficientResourcesForValidate,
)) => {}
other => panic!("Unexpected result: {other:?}"),
}
}
#[test]
fn deploy_account_transaction_v3_should_return_an_error_due_to_not_enough_balance() {
let (mut starknet, account_class_hash) = setup();
let tx = test_deploy_account_transaction_v3(account_class_hash, 0, 4000, 0, 0);
match starknet.add_deploy_account_transaction(BroadcastedDeployAccountTransaction::V3(tx)) {
Err(Error::TransactionValidationError(
TransactionValidationError::InsufficientAccountBalance,
)) => {}
other => panic!("Unexpected result: {other:?}"),
}
}
fn get_strk_balance(starknet: &Starknet, address: ContractAddress) -> Felt {
let balance_storage_var_address =
get_storage_var_address("ERC20_balances", &[address.into()]).unwrap().into();
let erc20_address =
starknet.block_context.chain_info().fee_token_addresses.strk_fee_token_address;
starknet
.pre_confirmed_state
.get_storage_at(erc20_address, balance_storage_var_address)
.unwrap()
}
fn set_strk_balance(starknet: &mut Starknet, address: ContractAddress, amount: Felt) {
let balance_storage_var_address =
get_storage_var_address("ERC20_balances", &[address.into()]).unwrap().into();
let erc20_address =
starknet.block_context.chain_info().fee_token_addresses.strk_fee_token_address;
starknet
.pre_confirmed_state
.set_storage_at(erc20_address, balance_storage_var_address, amount)
.unwrap();
}
#[test]
fn deploy_account_transaction_v3_should_return_an_error_if_insufficient_l1_gas_bounds() {
let (mut starknet, account_class_hash) = setup();
let tx = test_deploy_account_transaction_v3(account_class_hash, 0, 1, 0, 0);
match starknet.add_deploy_account_transaction(BroadcastedDeployAccountTransaction::V3(tx)) {
Err(Error::TransactionValidationError(
TransactionValidationError::InsufficientResourcesForValidate,
)) => {}
other => panic!("Unexpected result: {other:?}"),
}
}
#[test]
fn deploy_account_transaction_v3_should_return_an_error_if_only_l1_and_l2_gas_specified() {
let (mut starknet, account_class_hash) = setup();
let tx = test_deploy_account_transaction_v3(account_class_hash, 0, 1000, 0, 1e7 as u64);
match starknet.add_deploy_account_transaction(BroadcastedDeployAccountTransaction::V3(tx)) {
Err(Error::TransactionValidationError(
TransactionValidationError::InsufficientResourcesForValidate,
)) => {}
other => panic!("Unexpected result: {other:?}"),
}
}
#[test]
fn deploy_account_transaction_v3_should_return_an_error_if_insufficient_l2_gas_bounds() {
let (mut starknet, account_class_hash) = setup();
let tx = test_deploy_account_transaction_v3(account_class_hash, 0, 1000, 1000, 1);
match starknet.add_deploy_account_transaction(BroadcastedDeployAccountTransaction::V3(tx)) {
Err(Error::TransactionValidationError(
TransactionValidationError::InsufficientResourcesForValidate,
)) => {}
other => panic!("Unexpected result: {other:?}"),
}
}
fn successfully_deploy_acc_v3(init_balance: u64, l1_gas: u64, l1_data_gas: u64, l2_gas: u64) {
let (mut starknet, account_class_hash) = setup();
let transaction =
test_deploy_account_transaction_v3(account_class_hash, 0, l1_gas, l1_data_gas, l2_gas);
let executable_tx = BroadcastedDeployAccountTransaction::V3(transaction.clone())
.create_sn_api_deploy_account(&DEVNET_DEFAULT_CHAIN_ID.to_felt())
.unwrap();
let account_address = ContractAddress::from(executable_tx.contract_address);
let account_balance_before_deployment = Felt::from(init_balance);
set_strk_balance(&mut starknet, account_address, account_balance_before_deployment);
let (txn_hash, _) = starknet
.add_deploy_account_transaction(BroadcastedDeployAccountTransaction::V3(transaction))
.unwrap();
let txn = starknet.transactions.get_by_hash_mut(&txn_hash).unwrap();
assert_eq!(txn.finality_status, TransactionFinalityStatus::AcceptedOnL2);
assert_eq!(txn.execution_result.status(), TransactionExecutionStatus::Succeeded);
assert_eq!(
starknet.get_class_hash_at(&BlockId::Tag(BlockTag::Latest), account_address).unwrap(),
account_class_hash,
);
let account_balance_after_deployment = get_strk_balance(&starknet, account_address);
assert!(account_balance_before_deployment > account_balance_after_deployment);
}
#[test]
fn test_deploy_account_transaction_v3_successful_execution_if_only_l1_gas() {
successfully_deploy_acc_v3(1e6 as u64, 4000, 0, 0);
}
#[test]
fn test_deploy_account_transaction_v3_successful_execution_if_all_gas_bounds() {
successfully_deploy_acc_v3(1e8 as u64, 0, 1000, 1e7 as u64);
}
/// Initializes starknet with erc20 contracts, 1 declared contract class. Gas price is set to 1
fn setup() -> (Starknet, ClassHash) {
let mut starknet = Starknet::default();
for erc20_address in [ETH_ERC20_CONTRACT_ADDRESS, STRK_ERC20_CONTRACT_ADDRESS] {
let erc20_contract =
predeployed::tests::create_erc20_at_address(erc20_address).unwrap();
erc20_contract.deploy(&mut starknet.pre_confirmed_state).unwrap();
}
let contract_class = cairo_0_account_without_validations(); // TODO use cairo1
let class_hash = contract_class.generate_hash().unwrap();
starknet
.pre_confirmed_state
.declare_contract_class(class_hash, None, contract_class.into())
.unwrap();
starknet.block_context = Starknet::init_block_context(
nonzero!(GAS_PRICE),
nonzero!(GAS_PRICE),
nonzero!(GAS_PRICE),
nonzero!(GAS_PRICE),
nonzero!(GAS_PRICE),
nonzero!(GAS_PRICE),
ETH_ERC20_CONTRACT_ADDRESS,
STRK_ERC20_CONTRACT_ADDRESS,
DEVNET_DEFAULT_CHAIN_ID,
DEVNET_DEFAULT_STARTING_BLOCK_NUMBER,
);
starknet.restart_pre_confirmed_block().unwrap();
(starknet, class_hash)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/messaging/ethereum.rs | crates/starknet-devnet-core/src/messaging/ethereum.rs | #![allow(clippy::expect_used)]
use std::collections::BTreeMap;
use std::str::FromStr;
use alloy::hex::ToHexExt;
use alloy::primitives::{Address, B256, U256};
use alloy::providers::{Provider, ProviderBuilder};
use alloy::rpc::types::{BlockNumberOrTag, Filter, Log};
use alloy::signers::Signer;
use alloy::signers::local::{LocalSignerError, PrivateKeySigner};
use alloy::sol;
use alloy::sol_types::SolEvent;
use alloy::transports::RpcError;
use starknet_rs_core::types::{Felt, Hash256};
use starknet_types::felt::felt_from_prefixed_hex;
use starknet_types::rpc::contract_address::ContractAddress;
use starknet_types::rpc::messaging::{MessageToL1, MessageToL2};
use tracing::{trace, warn};
use url::Url;
use crate::error::{DevnetResult, Error, MessagingError};
pub struct EthDevnetAccount {
pub address: &'static str,
pub private_key: &'static str,
}
/// Default account 0 for most used ethereum devnets (at least hardhat and anvil).
/// Mnemonic: test test test test test test test test test test test junk
/// Derivation path: m/44'/60'/0'/0/
pub const ETH_ACCOUNT_DEFAULT: EthDevnetAccount = EthDevnetAccount {
address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
private_key: "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
};
impl<T> From<RpcError<T>> for Error {
fn from(e: RpcError<T>) -> Self {
Error::MessagingError(MessagingError::AlloyError(format!(
"RpcError: {:?}",
e.as_error_resp()
)))
}
}
impl From<LocalSignerError> for Error {
fn from(e: LocalSignerError) -> Self {
Error::MessagingError(MessagingError::AlloyError(format!("LocalSignerError: {e}")))
}
}
sol! {
#[sol(rpc)]
event LogMessageToL2(
address indexed from_address,
uint256 indexed to_address,
uint256 indexed selector,
uint256[] payload,
uint256 nonce,
uint256 fee
);
}
sol! {
#[sol(rpc)]
MockStarknetMessaging,
"contracts/l1-l2-artifacts/MockStarknetMessaging.json",
}
async fn assert_address_contains_any_code(
provider: &dyn Provider,
address: Address,
) -> DevnetResult<()> {
let messaging_contract_code = provider.get_code_at(address).await.map_err(|e| {
Error::MessagingError(MessagingError::AlloyError(format!(
"Failed retrieving contract code at address {address}: {e}"
)))
})?;
if messaging_contract_code.is_empty() {
return Err(Error::MessagingError(MessagingError::AlloyError(format!(
"The specified address ({address:#x}) contains no contract"
))));
}
Ok(())
}
#[derive(Clone)]
/// Ethereum related configuration and types.
pub struct EthereumMessaging {
wallet: PrivateKeySigner,
messaging_contract_address: Address,
node_url: Url,
/// This value must be dumped to avoid re-fetching already processed messages.
pub(crate) last_fetched_block: u64,
// A nonce verification may be added, with a nonce counter here.
// If so, it must be dumped too.
}
impl EthereumMessaging {
/// Instantiates a new `EthereumMessaging`.
///
/// # Arguments
///
/// * `rpc_url` - The L1 node RPC URL.
/// * `contract_address` - The messaging contract address deployed on L1 node.
/// * `deployer_account_private_key` - The private key of the funded account on L1 node to
pub async fn new(
rpc_url: &str,
contract_address: Option<&str>,
deployer_account_private_key: Option<&str>,
) -> DevnetResult<EthereumMessaging> {
let node_url: Url = rpc_url.parse().map_err(|e| {
Error::MessagingError(MessagingError::AlloyError(format!(
"Failed to parse RPC URL '{rpc_url}': {e}"
)))
})?;
let provider = ProviderBuilder::new().connect_http(node_url.clone());
let chain_id = provider.get_chain_id().await?;
let last_fetched_block = provider.get_block_number().await?;
let private_key = match deployer_account_private_key {
Some(private_key) => private_key,
None => ETH_ACCOUNT_DEFAULT.private_key,
};
let wallet = PrivateKeySigner::from_str(private_key)?.with_chain_id(chain_id.into());
let mut ethereum = EthereumMessaging {
wallet,
messaging_contract_address: Address::ZERO,
node_url,
last_fetched_block,
};
if let Some(address) = contract_address {
ethereum.messaging_contract_address = Address::from_str(address).map_err(|e| {
Error::MessagingError(MessagingError::AlloyError(format!(
"Address {address} can't be parsed from string: {e}",
)))
})?;
assert_address_contains_any_code(&provider, ethereum.messaging_contract_address)
.await?;
} else {
let cancellation_delay_seconds = U256::from(60 * 60 * 24);
ethereum.messaging_contract_address =
ethereum.deploy_messaging_contract(cancellation_delay_seconds).await?;
}
Ok(ethereum)
}
/// Returns the url of the ethereum node currently in used.
pub fn node_url(&self) -> String {
self.node_url.to_string()
}
/// Returns address of the messaging contract on L1 node.
pub fn messaging_contract_address(&self) -> Address {
self.messaging_contract_address
}
/// Fetches all the messages that were not already fetched from the L1 node.
pub async fn fetch_messages(&mut self) -> DevnetResult<Vec<MessageToL2>> {
let provider =
ProviderBuilder::new().wallet(self.wallet.clone()).connect_http(self.node_url.clone());
let chain_latest_block = provider.get_block_number().await?;
let to_block = chain_latest_block;
// +1 exclude the latest fetched block the last time this function was called.
let from_block = self.last_fetched_block + 1;
let mut messages = vec![];
self.fetch_logs(from_block, to_block).await?.into_iter().for_each(
|(block_number, block_logs)| {
trace!(
"Converting {} logs of block {block_number} into MessageToL2",
block_logs.len(),
);
block_logs.into_iter().for_each(|log| match message_to_l2_from_log(log) {
Ok(m) => messages.push(m),
Err(e) => warn!("Log from L1 node cannot be converted to MessageToL2: {e}"),
})
},
);
self.last_fetched_block = to_block;
Ok(messages)
}
/// Sends the list of given messages to L1. The messages are sent to
/// the mocked contract, `mockSendMessageFromL2` entrypoint.
///
/// # Arguments
///
/// * `messages` - The list of messages to be sent.
pub async fn send_mock_messages(&self, messages: &[MessageToL1]) -> DevnetResult<()> {
if messages.is_empty() {
return Ok(());
}
let provider =
ProviderBuilder::new().wallet(self.wallet.clone()).connect_http(self.node_url.clone());
let contract = MockStarknetMessaging::new(self.messaging_contract_address, provider);
for message in messages {
let message_hash = U256::from_be_bytes(*message.hash().as_bytes());
trace!("Sending message to L1: [{:064x}]", message_hash);
let from_address = felt_to_u256(message.from_address.into());
let to_address = felt_to_u256(message.to_address.clone().into());
let payload = message.payload.iter().map(|f| felt_to_u256(*f)).collect::<Vec<_>>();
let tx = contract
.mockSendMessageFromL2(from_address, to_address, payload)
.send()
.await
.map_err(|e| {
Error::MessagingError(MessagingError::AlloyError(format!(
"Failed to send mock message from L2: {e}"
)))
})?;
// Wait for transaction receipt
match tx.get_receipt().await {
Ok(receipt) => trace!(
"Message {message_hash:064x} sent on L1 with transaction hash {:#x}",
receipt.transaction_hash
),
Err(_) => {
return Err(Error::MessagingError(MessagingError::AlloyError(format!(
"No receipt found for the tx of message hash: {message_hash:064x}",
))));
}
}
}
Ok(())
}
/// Fetches logs in the given block range and returns a `HashMap` with the list of logs for each
/// block number.
///
/// There is no pagination on ethereum, and no hard limit on block range.
/// Fetching too much blocks may result in RPC request error.
/// For this reason, the caller may wisely choose the range.
///
/// # Arguments
///
/// * `from_block` - The first (included) block of which logs must be fetched.
/// * `to_block` - The last (included) block of which logs must be fetched.
async fn fetch_logs(
&self,
from_block: u64,
to_block: u64,
) -> DevnetResult<BTreeMap<u64, Vec<Log>>> {
trace!("Fetching logs for blocks {} - {}.", from_block, to_block);
let mut block_to_logs = BTreeMap::<u64, Vec<Log>>::new();
let provider = ProviderBuilder::new().connect_http(self.node_url.clone());
// `sendMessageToL2` topic.
let log_msg_to_l2_topic =
B256::from_str("0xdb80dd488acf86d17c747445b0eabb5d57c541d3bd7b6b87af987858e5066b2b")
.map_err(|err| {
Error::MessagingError(MessagingError::ConversionError(err.to_string()))
})?;
let filter = Filter::new()
.from_block(BlockNumberOrTag::Number(from_block))
.to_block(BlockNumberOrTag::Number(to_block))
.address(self.messaging_contract_address)
.event_signature(log_msg_to_l2_topic);
let logs = provider.get_logs(&filter).await?;
for log in logs {
if let Some(block_number) = log.block_number {
block_to_logs.entry(block_number).or_default().push(log);
}
}
Ok(block_to_logs)
}
/// Deploys an instance of the `MockStarknetMessaging` contract and returns it's address.
///
/// # Arguments
///
/// * `cancellation_delay_seconds` - Cancellation delay in seconds passed to the contract's
/// constructor.
pub async fn deploy_messaging_contract(
&self,
cancellation_delay_seconds: U256,
) -> DevnetResult<Address> {
let provider =
ProviderBuilder::new().wallet(self.wallet.clone()).connect_http(self.node_url.clone());
let contract = MockStarknetMessaging::deploy(provider, cancellation_delay_seconds)
.await
.map_err(|e| {
Error::MessagingError(MessagingError::AlloyError(format!(
"Failed deploying MockStarknetMessaging contract: {e}"
)))
})?;
Ok(*contract.address())
}
}
/// Converts an ethereum log into a `MessageToL2`.
///
/// # Arguments
///
/// * `log` - The log to be converted.
pub fn message_to_l2_from_log(log: Log) -> DevnetResult<MessageToL2> {
let l1_transaction_hash = log.transaction_hash.map(|h| Hash256::from_bytes(*h));
let decoded = LogMessageToL2::decode_log(&log.inner).map_err(|e| {
Error::MessagingError(MessagingError::AlloyError(format!("Log parsing failed {e}")))
})?;
let from_address = address_to_felt(&decoded.from_address)?;
let contract_address = ContractAddress::new(u256_to_felt(&decoded.to_address)?)?;
let entry_point_selector = u256_to_felt(&decoded.selector)?;
let nonce = u256_to_felt(&decoded.nonce)?;
let paid_fee_on_l1 = u256_to_felt(&decoded.fee)?;
let payload = decoded.payload.iter().map(u256_to_felt).collect::<Result<_, _>>()?;
Ok(MessageToL2 {
l1_transaction_hash,
l2_contract_address: contract_address,
entry_point_selector,
l1_contract_address: ContractAddress::new(from_address)?,
payload,
paid_fee_on_l1,
nonce,
})
}
/// Converts an `U256` into a `Felt`.
///
/// # Arguments
///
/// * `v` - The `U256` to be converted.
fn u256_to_felt(v: &U256) -> DevnetResult<Felt> {
Ok(Felt::from_bytes_be(&v.to_be_bytes()))
}
/// Converts an `Felt` into a `U256`.
///
/// # Arguments
///
/// * `f` - The `Felt` to be converted.
fn felt_to_u256(f: Felt) -> U256 {
U256::from_be_bytes(f.to_bytes_be())
}
/// Converts an `Address` into a `Felt`.
///
/// # Arguments
///
/// * `address` - The `Address` to be converted.
fn address_to_felt(address: &Address) -> DevnetResult<Felt> {
Ok(felt_from_prefixed_hex(&format!("0x{}", address.encode_hex()))?)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_message_to_l2_from_log() {
// Test based on Goerli tx hash:
// 0x6182c63599a9638272f1ce5b5cadabece9c81c2d2b8f88ab7a294472b8fce8b
let from_address = "0x000000000000000000000000be3C44c09bc1a3566F3e1CA12e5AbA0fA4Ca72Be";
let to_address = "0x039dc79e64f4bb3289240f88e0bae7d21735bef0d1a51b2bf3c4730cb16983e1";
let selector = "0x02f15cff7b0eed8b9beb162696cf4e3e0e35fa7032af69cd1b7d2ac67a13f40f";
let nonce = 783082_u128;
let fee = 30000_u128;
// Payload two values: [1, 2].
let payload_buf = hex::decode("000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000bf2ea0000000000000000000000000000000000000000000000000000000000007530000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002").unwrap();
let payload: Vec<Felt> = vec![1.into(), 2.into()];
let inner = alloy::primitives::Log {
address: Address::from_str("0xde29d060D45901Fb19ED6C6e959EB22d8626708e").unwrap(),
data: alloy::primitives::LogData::new_unchecked(
vec![
B256::from_str(
"0xdb80dd488acf86d17c747445b0eabb5d57c541d3bd7b6b87af987858e5066b2b",
)
.unwrap(),
B256::from_str(from_address).unwrap(),
B256::from_str(to_address).unwrap(),
B256::from_str(selector).unwrap(),
],
payload_buf.clone().into(),
),
};
let expected_message = MessageToL2 {
l1_transaction_hash: None,
l1_contract_address: ContractAddress::new(
felt_from_prefixed_hex(from_address).unwrap(),
)
.unwrap(),
l2_contract_address: ContractAddress::new(felt_from_prefixed_hex(to_address).unwrap())
.unwrap(),
entry_point_selector: felt_from_prefixed_hex(selector).unwrap(),
payload,
nonce: nonce.into(),
paid_fee_on_l1: fee.into(),
};
let log = Log { inner, block_number: None, transaction_hash: None, ..Default::default() };
let message = message_to_l2_from_log(log).unwrap();
assert_eq!(message, expected_message);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-core/src/messaging/mod.rs | crates/starknet-devnet-core/src/messaging/mod.rs | //! Messaging module.
//!
//! This module contains code related to messaging feature.
//! The messaging is composed of two major actors:
//! 1. The Starknet sequencer, which is in charge of gathering messages from L1 and executing
//! them.
//! 2. The Starknet Core Contract, an Ethereum contract, that is generating the logs to send
//! message to L2 and computing/ref-counting messages hashes for messages sent to L1.
//!
//! Being a devnet, this project is embedding an Ethereum contract (MockStarknetMessaging)
//! that mocks the behavior of the Starknet Core Contract by adding a method to manually
//! increment the ref-counting of message hashes.
//! This ensures that messages can be consumed on L1 without actually waiting for the
//! proof to be generated (at it is done on Starknet in production).
//!
//! # Receive message from L1
//! The Starknet sequencer (the devnet being the sequencer in this project)
//! is in charge of fetching the logs from Starknet Core Contract from Ethereum network.
//! In this project, the logs are emitted by the MockStarknetMessaging contract method
//! `sendMessageToL2`.
//! Once a log is gathered, a `L1HandlerTransaction` is executed internally, without
//! being signed by any account.
//!
//! # Send message to L1
//! To send messages to L1, any Starknet contract can use the `send_message_to_l1` syscall.
//! This will have the effect of adding, in the transaction output, the content
//! of the message.
//! By collecting those messages from transactions output, the devnet
//! uses the mocked functionality of manually incrementing the ref-count of a message
//! to make it available for consumption on L1.
//! This is done my sending a transaction to the Ethereum node, to the MockStarknetMessaging
//! contract (`mockSendMessageFromL2` entrypoint).
use std::collections::HashMap;
use alloy::primitives::B256;
use starknet_rs_core::types::{ExecutionResult, Felt, Hash256};
use starknet_types::rpc::block::BlockId;
use starknet_types::rpc::messaging::{MessageToL1, MessageToL2};
use crate::StarknetBlock;
use crate::error::{DevnetResult, Error, MessagingError};
use crate::starknet::Starknet;
use crate::traits::HashIdentified;
pub mod ethereum;
pub use ethereum::EthereumMessaging;
#[derive(Default)]
pub struct MessagingBroker {
/// The ethereum broker to send transaction / call contracts using alloy.
pub(crate) ethereum: Option<EthereumMessaging>,
/// The last local (starknet) block for which messages have been collected
/// and sent.
pub last_local_block: u64,
/// A local queue of `MessageToL1` hashes generated by cairo contracts.
/// For each time a message is supposed to be sent to L1, it is stored in this
/// queue. The user may consume those messages using `consume_message_from_l2`
/// to actually test `MessageToL1` emitted without running L1 node.
pub l2_to_l1_messages_hashes: HashMap<B256, u64>,
/// This list of messages that will be sent to L1 node at the next `postman/flush`.
pub l2_to_l1_messages_to_flush: Vec<MessageToL1>,
/// Mapping of L1 transaction hash to a chronological sequence of generated L2 transactions.
pub l1_to_l2_tx_hashes: HashMap<B256, Vec<Felt>>,
}
impl MessagingBroker {
/// Configures the ethereum broker.
///
/// # Arguments
///
/// * `ethereum_messaging` - The `EthereumMessaging` to use as broker.
pub fn configure_ethereum(&mut self, ethereum_messaging: EthereumMessaging) {
self.ethereum = Some(ethereum_messaging);
}
/// Returns the url of the ethereum node currently in used, or `None` otherwise.
pub fn ethereum_url(&self) -> Option<String> {
self.ethereum.as_ref().map(|m| m.node_url())
}
/// Returns a reference to the ethereum instance if configured, an error otherwise.
pub fn ethereum_ref(&self) -> DevnetResult<&EthereumMessaging> {
self.ethereum.as_ref().ok_or(Error::MessagingError(MessagingError::NotConfigured))
}
/// Returns a mutable reference to the ethereum instance if configured, an error otherwise.
pub fn ethereum_mut(&mut self) -> DevnetResult<&mut EthereumMessaging> {
self.ethereum.as_mut().ok_or(Error::MessagingError(MessagingError::NotConfigured))
}
}
impl Starknet {
/// Configures the messaging from the given L1 node parameters.
/// Calling this function multiple time will overwrite the previous
/// configuration, if any.
///
/// # Arguments
///
/// * `rpc_url` - The L1 node RPC URL.
/// * `contract_address` - The messaging contract address deployed on L1 node.
/// * `deployer_account_private_key` - The private key of the funded account on L1 node to
/// perform the role of signer.
pub async fn configure_messaging(
&mut self,
rpc_url: &str,
contract_address: Option<&str>,
deployer_account_private_key: Option<&str>,
) -> DevnetResult<String> {
tracing::trace!("Configuring messaging: {}", rpc_url);
self.messaging.configure_ethereum(
EthereumMessaging::new(rpc_url, contract_address, deployer_account_private_key).await?,
);
Ok(format!("0x{:x}", self.messaging.ethereum_ref()?.messaging_contract_address()))
}
/// Retrieves the ethereum node URL, if configured.
pub fn get_ethereum_url(&self) -> Option<String> {
self.messaging.ethereum_url()
}
/// Sets the latest local block processed by messaging.
pub fn set_latest_local_block(&mut self, latest_local_block: u64) {
self.messaging.last_local_block = latest_local_block;
}
/// Collects all messages found between
/// the current messaging latest block and the Latest Starknet block,
/// including both blocks.
/// This function register the messages in two fashions:
/// 1. Add each message to the `l2_to_l1_messages_to_flush`.
/// 2. Increment the counter for the hash of each message into `l2_to_l1_messages_hashes`.
///
/// Returns all the messages currently collected and not flushed.
pub async fn collect_messages_to_l1(&mut self) -> DevnetResult<Vec<MessageToL1>> {
let from_block = if self.messaging.last_local_block != 0 {
self.messaging.last_local_block
} else {
self.blocks.starting_block_number
};
let pre_confirmed_block_number = self.blocks.pre_confirmed_block.block_number().0;
// if pre_confirmed_block_number is 0, there is no L2 confirmed block to process
if pre_confirmed_block_number == 0 {
return Ok(vec![]);
}
let to_block = pre_confirmed_block_number - 1;
match self
.blocks
.get_blocks(Some(BlockId::Number(from_block)), Some(BlockId::Number(to_block)))
{
Ok(blocks) => {
let mut messages = vec![];
let mut last_processed_block: u64 = 0;
for block in blocks {
messages.extend(self.get_block_messages(block)?);
last_processed_block = block.header.block_header_without_hash.block_number.0;
}
for message in &messages {
let hash = B256::new(*message.hash().as_bytes());
let count = self.messaging.l2_to_l1_messages_hashes.entry(hash).or_insert(0);
*count += 1;
}
// +1 to avoid latest block to be processed twice.
self.messaging.last_local_block = last_processed_block + 1;
self.messaging.l2_to_l1_messages_to_flush.extend(messages);
Ok(self.messaging.l2_to_l1_messages_to_flush.clone())
}
Err(Error::NoBlock) => {
// We're 1 block ahead of latest block, no messages can be collected.
Ok(self.messaging.l2_to_l1_messages_to_flush.clone())
}
Err(e) => Err(e),
}
}
/// Sends (flush) all the messages in `l2_to_l1_messages_to_flush` to L1 node.
/// Returns the list of sent messages.
pub async fn send_messages_to_l1(&mut self) -> DevnetResult<Vec<MessageToL1>> {
let ethereum = self.messaging.ethereum_ref()?;
ethereum.send_mock_messages(&self.messaging.l2_to_l1_messages_to_flush).await?;
let messages = self.messaging.l2_to_l1_messages_to_flush.clone();
self.messaging.l2_to_l1_messages_to_flush.clear();
Ok(messages)
}
/// Consumes a `MessageToL1` that is registered in `l2_to_l1_messages`.
/// If the count related to the message is hash is already 0, an error is returned,
/// the message's hash otherwise.
///
/// # Arguments
///
/// * `message` - The message to consume.
pub async fn consume_l2_to_l1_message(
&mut self,
message: &MessageToL1,
) -> DevnetResult<Hash256> {
// Ensure latest messages are collected before consuming the message.
self.collect_messages_to_l1().await?;
let hash = B256::new(*message.hash().as_bytes());
let count = self.messaging.l2_to_l1_messages_hashes.entry(hash).or_insert(0);
if *count > 0 {
*count -= 1;
Ok(message.hash())
} else {
Err(Error::MessagingError(MessagingError::MessageToL1NotPresent(hash.to_string())))
}
}
/// Fetches all messages from L1 and converts the ethereum log into `MessageToL2`.
pub async fn fetch_messages_to_l2(&mut self) -> DevnetResult<Vec<MessageToL2>> {
let ethereum = self.messaging.ethereum_mut()?;
let messages = ethereum.fetch_messages().await?;
Ok(messages)
}
/// Collects all messages for all the transactions of the given block.
///
/// # Arguments
///
/// * `block` - The block from which messages are collected.
fn get_block_messages(&self, block: &StarknetBlock) -> DevnetResult<Vec<MessageToL1>> {
let mut messages = vec![];
block.get_transactions().iter().for_each(|transaction_hash| {
if let Ok(transaction) =
self.transactions.get_by_hash(*transaction_hash).ok_or(Error::NoTransaction)
{
// As we will send the messages to L1 node, we don't want to include
// the messages of reverted transactions.
if let ExecutionResult::Succeeded = transaction.execution_result {
messages.extend(transaction.get_l2_to_l1_messages())
}
}
});
Ok(messages)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/config.rs | crates/starknet-devnet-server/src/config.rs | use std::net::IpAddr;
use serde::Serialize;
use starknet_core::starknet::starknet_config::StarknetConfig;
#[derive(Debug, Clone, Serialize)]
pub struct ServerConfig {
pub host: IpAddr,
pub port: u16,
pub timeout: u16,
#[serde(skip)]
pub log_request: bool,
#[serde(skip)]
pub log_response: bool,
pub restricted_methods: Option<Vec<String>>,
}
#[derive(Serialize)]
pub struct DevnetConfig {
#[serde(flatten)]
pub(crate) starknet_config: StarknetConfig,
pub(crate) server_config: ServerConfig,
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/subscribe.rs | crates/starknet-devnet-server/src/subscribe.rs | use std::collections::HashMap;
use std::sync::Arc;
use axum::extract::ws::{Message, WebSocket};
use futures::SinkExt;
use futures::stream::SplitSink;
use serde::{self, Deserialize, Serialize};
use starknet_core::starknet::events::check_if_filter_applies_for_event;
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::emitted_event::SubscriptionEmittedEvent;
use starknet_types::felt::TransactionHash;
use starknet_types::rpc::block::{BlockHeader, ReorgData};
use starknet_types::rpc::transaction_receipt::TransactionReceipt;
use starknet_types::rpc::transactions::{
TransactionFinalityStatus, TransactionStatus, TransactionWithHash,
};
use tokio::sync::Mutex;
use crate::api::error::ApiError;
use crate::api::models::SubscriptionId;
use crate::rpc_core::request::Id;
pub type SocketId = u64;
#[derive(Default)]
pub struct SocketCollection {
sockets: HashMap<SocketId, SocketContext>,
}
impl SocketCollection {
pub fn get_mut(&mut self, socket_id: &SocketId) -> Result<&mut SocketContext, ApiError> {
self.sockets.get_mut(socket_id).ok_or(ApiError::StarknetDevnetError(
starknet_core::error::Error::UnexpectedInternalError {
msg: format!("Unregistered socket ID: {socket_id}"),
},
))
}
/// Assigns a random socket ID to the socket whose `socket_writer` is provided. Returns the ID.
pub fn insert(&mut self, socket_writer: Arc<Mutex<SplitSink<WebSocket, Message>>>) -> SocketId {
let socket_id = rand::random();
self.sockets.insert(socket_id, SocketContext::from_sender(socket_writer));
socket_id
}
pub fn remove(&mut self, socket_id: &SocketId) {
self.sockets.remove(socket_id);
}
pub async fn notify_subscribers(&self, notifications: &[NotificationData]) {
for (_, socket_context) in self.sockets.iter() {
for notification in notifications {
socket_context.notify_subscribers(notification).await;
}
}
}
pub fn clear(&mut self) {
self.sockets
.iter_mut()
.for_each(|(_, socket_context)| socket_context.subscriptions.clear());
tracing::info!("Websocket memory cleared. No subscribers.");
}
}
#[derive(Debug)]
pub struct AddressFilter {
address_container: Vec<ContractAddress>,
}
impl AddressFilter {
pub(crate) fn new(address_container: Vec<ContractAddress>) -> Self {
Self { address_container }
}
pub(crate) fn passes(&self, address: &ContractAddress) -> bool {
self.address_container.is_empty() || self.address_container.contains(address)
}
}
#[derive(Debug, Clone)]
pub struct StatusFilter {
status_container: Vec<TransactionFinalityStatus>,
}
impl StatusFilter {
pub(crate) fn new(status_container: Vec<TransactionFinalityStatus>) -> Self {
Self { status_container }
}
pub(crate) fn passes(&self, status: &TransactionFinalityStatus) -> bool {
self.status_container.is_empty() || self.status_container.contains(status)
}
}
#[derive(Debug)]
pub enum Subscription {
NewHeads,
TransactionStatus {
transaction_hash: TransactionHash,
},
NewTransactions {
address_filter: AddressFilter,
status_filter: StatusFilter,
},
NewTransactionReceipts {
address_filter: AddressFilter,
status_filter: StatusFilter,
},
Events {
address: Option<ContractAddress>,
keys_filter: Option<Vec<Vec<Felt>>>,
status_filter: StatusFilter,
},
}
impl Subscription {
fn confirm(&self, id: SubscriptionId) -> SubscriptionConfirmation {
match self {
Subscription::NewHeads => SubscriptionConfirmation::NewSubscription(id),
Subscription::TransactionStatus { .. } => SubscriptionConfirmation::NewSubscription(id),
Subscription::NewTransactions { .. } => SubscriptionConfirmation::NewSubscription(id),
Subscription::NewTransactionReceipts { .. } => {
SubscriptionConfirmation::NewSubscription(id)
}
Subscription::Events { .. } => SubscriptionConfirmation::NewSubscription(id),
}
}
pub fn matches(&self, notification: &NotificationData) -> bool {
match (self, notification) {
(Subscription::NewHeads, NotificationData::NewHeads(_)) => true,
(
Subscription::TransactionStatus { transaction_hash: subscription_hash },
NotificationData::TransactionStatus(notification),
) => subscription_hash == ¬ification.transaction_hash,
(
Subscription::NewTransactions { address_filter, status_filter },
NotificationData::NewTransaction(NewTransactionNotification {
tx,
finality_status,
}),
) => match tx.get_sender_address() {
Some(address) => {
address_filter.passes(&address) && status_filter.passes(finality_status)
}
None => true,
},
(
Subscription::NewTransactionReceipts { address_filter, status_filter },
NotificationData::NewTransactionReceipt(NewTransactionReceiptNotification {
tx_receipt,
sender_address,
}),
) => {
status_filter.passes(tx_receipt.finality_status())
&& match sender_address {
Some(address) => address_filter.passes(address),
None => true,
}
}
(
Subscription::Events { address, keys_filter, status_filter },
NotificationData::Event(event_with_finality_status),
) => {
let event = (&event_with_finality_status.emitted_event).into();
check_if_filter_applies_for_event(address, keys_filter, &event)
&& status_filter.passes(&event_with_finality_status.finality_status)
}
(
Subscription::NewHeads
| Subscription::TransactionStatus { .. }
| Subscription::Events { .. }
| Subscription::NewTransactions { .. }
| Subscription::NewTransactionReceipts { .. },
NotificationData::Reorg(_),
) => true, // All subscriptions require a reorg notification
_ => false,
}
}
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
#[cfg_attr(test, derive(Deserialize))]
pub(crate) enum SubscriptionConfirmation {
NewSubscription(SubscriptionId),
Unsubscription(bool),
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(test, derive(Deserialize))]
pub struct NewTransactionStatus {
pub transaction_hash: TransactionHash,
pub status: TransactionStatus,
}
#[derive(Debug, Clone)]
pub struct TransactionHashWrapper {
pub hash: TransactionHash,
pub sender_address: Option<ContractAddress>,
}
impl Serialize for TransactionHashWrapper {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
self.hash.serialize(serializer)
}
}
impl<'de> Deserialize<'de> for TransactionHashWrapper {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let hash = Felt::deserialize(deserializer)?;
Ok(TransactionHashWrapper { hash, sender_address: None })
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TransactionFinalityStatusWithoutL1 {
PreConfirmed,
AcceptedOnL2,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TransactionStatusWithoutL1 {
Received,
Candidate,
PreConfirmed,
AcceptedOnL2,
}
impl From<TransactionFinalityStatusWithoutL1> for TransactionFinalityStatus {
fn from(status: TransactionFinalityStatusWithoutL1) -> Self {
match status {
TransactionFinalityStatusWithoutL1::PreConfirmed => Self::PreConfirmed,
TransactionFinalityStatusWithoutL1::AcceptedOnL2 => Self::AcceptedOnL2,
}
}
}
impl From<TransactionStatusWithoutL1> for TransactionFinalityStatus {
fn from(status: TransactionStatusWithoutL1) -> Self {
match status {
TransactionStatusWithoutL1::Received => Self::Received,
TransactionStatusWithoutL1::Candidate => Self::Candidate,
TransactionStatusWithoutL1::PreConfirmed => Self::PreConfirmed,
TransactionStatusWithoutL1::AcceptedOnL2 => Self::AcceptedOnL2,
}
}
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(test, derive(Deserialize))]
pub struct NewTransactionNotification {
#[serde(flatten)]
pub tx: TransactionWithHash,
pub finality_status: TransactionFinalityStatus,
}
#[derive(Debug, Clone)]
pub struct NewTransactionReceiptNotification {
pub tx_receipt: TransactionReceipt,
pub sender_address: Option<ContractAddress>,
}
#[derive(Debug, Clone)]
pub enum NotificationData {
NewHeads(BlockHeader),
TransactionStatus(NewTransactionStatus),
NewTransaction(NewTransactionNotification),
NewTransactionReceipt(NewTransactionReceiptNotification),
Event(SubscriptionEmittedEvent),
Reorg(ReorgData),
}
#[derive(Debug, Serialize)]
#[serde(untagged)]
#[cfg_attr(test, derive(Deserialize))]
pub(crate) enum SubscriptionResponse {
Confirmation {
#[serde(rename = "id")]
rpc_request_id: Id,
result: SubscriptionConfirmation,
},
Notification(Box<SubscriptionNotification>),
}
#[derive(Serialize, Debug)]
#[cfg_attr(test, derive(Deserialize))]
#[serde(tag = "method", content = "params")]
pub(crate) enum SubscriptionNotification {
#[serde(rename = "starknet_subscriptionNewHeads")]
NewHeads { subscription_id: SubscriptionId, result: BlockHeader },
#[serde(rename = "starknet_subscriptionTransactionStatus")]
TransactionStatus { subscription_id: SubscriptionId, result: NewTransactionStatus },
#[serde(rename = "starknet_subscriptionNewTransaction")]
NewTransaction { subscription_id: SubscriptionId, result: NewTransactionNotification },
#[serde(rename = "starknet_subscriptionNewTransactionReceipts")]
NewTransactionReceipt { subscription_id: SubscriptionId, result: TransactionReceipt },
#[serde(rename = "starknet_subscriptionEvents")]
Event { subscription_id: SubscriptionId, result: SubscriptionEmittedEvent },
#[serde(rename = "starknet_subscriptionReorg")]
Reorg { subscription_id: SubscriptionId, result: ReorgData },
}
impl SubscriptionResponse {
fn to_serialized_rpc_response(&self) -> serde_json::Value {
let mut resp = serde_json::json!(self);
resp["jsonrpc"] = "2.0".into();
resp
}
}
pub struct SocketContext {
/// The sender part of the socket's own channel
sender: Arc<Mutex<SplitSink<WebSocket, Message>>>,
subscriptions: HashMap<SubscriptionId, Subscription>,
}
impl SocketContext {
pub fn from_sender(sender: Arc<Mutex<SplitSink<WebSocket, Message>>>) -> Self {
Self { sender, subscriptions: HashMap::new() }
}
async fn send_serialized(&self, resp: String) {
if let Err(e) = self.sender.lock().await.send(Message::Text(resp.into())).await {
tracing::error!("Failed writing to socket: {}", e.to_string());
}
}
pub async fn send_rpc_response(&self, result: serde_json::Value, id: Id) {
let resp_serialized = serde_json::json!({
"jsonrpc": "2.0",
"id": id,
"result": result,
})
.to_string();
tracing::trace!(target: "ws.json-rpc-api", response = %resp_serialized, "JSON-RPC response");
self.send_serialized(resp_serialized).await;
}
async fn send_subscription_response(&self, resp: SubscriptionResponse) {
let resp_serialized = resp.to_serialized_rpc_response().to_string();
tracing::trace!(target: "ws.subscriptions", response = %resp_serialized, "subscription response");
self.send_serialized(resp_serialized).await;
}
pub async fn subscribe(
&mut self,
rpc_request_id: Id,
subscription: Subscription,
) -> SubscriptionId {
loop {
let subscription_id: SubscriptionId = rand::random::<u64>().into();
if self.subscriptions.contains_key(&subscription_id) {
continue;
}
let confirmation = subscription.confirm(subscription_id);
self.subscriptions.insert(subscription_id, subscription);
self.send_subscription_response(SubscriptionResponse::Confirmation {
rpc_request_id,
result: confirmation,
})
.await;
return subscription_id;
}
}
pub async fn unsubscribe(
&mut self,
rpc_request_id: Id,
subscription_id: SubscriptionId,
) -> Result<(), ApiError> {
self.subscriptions.remove(&subscription_id).ok_or(ApiError::InvalidSubscriptionId)?;
self.send_subscription_response(SubscriptionResponse::Confirmation {
rpc_request_id,
result: SubscriptionConfirmation::Unsubscription(true),
})
.await;
Ok(())
}
pub async fn notify(&self, subscription_id: SubscriptionId, data: NotificationData) {
let notification_data = match data {
NotificationData::NewHeads(block_header) => {
SubscriptionNotification::NewHeads { subscription_id, result: block_header }
}
NotificationData::TransactionStatus(new_transaction_status) => {
SubscriptionNotification::TransactionStatus {
subscription_id,
result: new_transaction_status,
}
}
NotificationData::NewTransaction(tx_notification) => {
SubscriptionNotification::NewTransaction {
subscription_id,
result: tx_notification,
}
}
NotificationData::NewTransactionReceipt(tx_receipt_notification) => {
SubscriptionNotification::NewTransactionReceipt {
subscription_id,
result: tx_receipt_notification.tx_receipt,
}
}
NotificationData::Event(emitted_event) => {
SubscriptionNotification::Event { subscription_id, result: emitted_event }
}
NotificationData::Reorg(reorg_data) => {
SubscriptionNotification::Reorg { subscription_id, result: reorg_data }
}
};
self.send_subscription_response(SubscriptionResponse::Notification(Box::new(
notification_data,
)))
.await;
}
pub async fn notify_subscribers(&self, notification: &NotificationData) {
for (subscription_id, subscription) in self.subscriptions.iter() {
if subscription.matches(notification) {
self.notify(*subscription_id, notification.clone()).await;
}
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/lib.rs | crates/starknet-devnet-server/src/lib.rs | pub mod api;
mod config;
pub mod dump_util;
pub mod error;
pub mod restrictive_mode;
pub mod rpc_core;
/// handlers for axum server
pub mod rpc_handler;
pub mod server;
pub mod subscribe;
#[cfg(any(test, feature = "test_utils"))]
pub mod test_utils;
pub use config::ServerConfig;
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/restrictive_mode.rs | crates/starknet-devnet-server/src/restrictive_mode.rs | pub static DEFAULT_RESTRICTED_JSON_RPC_METHODS: &[&str] = &[
"devnet_mint",
"devnet_load",
"devnet_restart",
"devnet_createBlock",
"devnet_abortBlocks",
"devnet_impersonateAccount",
"devnet_autoImpersonate",
"devnet_getPredeployedAccounts",
];
pub(crate) fn is_json_rpc_method_restricted<T: AsRef<str>, U: AsRef<str>>(
json_rpc_method: T,
restricted_methods: &[U],
) -> bool {
restricted_methods.iter().any(|method| method.as_ref() == json_rpc_method.as_ref())
}
#[cfg(test)]
mod tests {
use super::DEFAULT_RESTRICTED_JSON_RPC_METHODS;
use crate::api::models::JsonRpcRequest;
use crate::restrictive_mode::is_json_rpc_method_restricted;
#[test]
fn test_provided_method_is_restricted() {
assert_is_restricted("devnet_mint", DEFAULT_RESTRICTED_JSON_RPC_METHODS);
assert_is_restricted("devnet_impersonateAccount", DEFAULT_RESTRICTED_JSON_RPC_METHODS);
assert_is_restricted(
"devnet_mint",
&["devnet_abortBlocks", "devnet_CreateBlocks", "devnet_mint"],
);
}
#[test]
fn test_provided_method_is_not_restricted() {
assert_is_not_restricted("devnet_getConfig", DEFAULT_RESTRICTED_JSON_RPC_METHODS);
assert_is_not_restricted("devnet_getAccountBalance", DEFAULT_RESTRICTED_JSON_RPC_METHODS);
}
#[test]
fn test_default_restricted_exist() {
let json_rpc_methods = JsonRpcRequest::all_variants_serde_renames();
for method in DEFAULT_RESTRICTED_JSON_RPC_METHODS {
assert!(json_rpc_methods.contains(&method.to_string()));
}
}
fn assert_is_restricted(method: &str, restricted_methods: &[&str]) {
assert!(is_json_rpc_method_restricted(method, restricted_methods));
}
fn assert_is_not_restricted(method: &str, restricted_methods: &[&str]) {
assert!(!is_json_rpc_method_restricted(method, restricted_methods));
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/test_utils.rs | crates/starknet-devnet-server/src/test_utils.rs | /// Returns Err if `text` does not contain `pattern`
pub fn assert_contains(text: &str, pattern: &str) -> Result<(), anyhow::Error> {
if !text.contains(pattern) {
anyhow::bail!(
"Failed content assertion!
Pattern: '{pattern}'
not present in
Text: '{text}'"
);
}
Ok(())
}
pub const EXPECTED_INVALID_BLOCK_ID_MSG: &str = "Invalid block ID. Expected object with key \
(block_hash or block_number) or tag \
('pre_confirmed' or 'latest' or 'l1_accepted').";
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/error.rs | crates/starknet-devnet-server/src/error.rs | #[derive(thiserror::Error, Debug)]
pub enum Error {
#[error(transparent)]
AxumError(#[from] axum::Error),
#[error("Failed conversion: {0}")]
ConversionError(String),
}
pub type ServerResult<T, E = Error> = Result<T, E>;
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/server.rs | crates/starknet-devnet-server/src/server.rs | use std::time::Duration;
use axum::Router;
use axum::body::{Body, Bytes};
use axum::extract::{DefaultBodyLimit, Request};
use axum::http::{HeaderValue, StatusCode};
use axum::middleware::Next;
use axum::response::{IntoResponse, Response};
use axum::routing::{IntoMakeService, get, post};
use http_body_util::BodyExt;
use reqwest::{Method, header};
use tokio::net::TcpListener;
use tower_http::cors::CorsLayer;
use tower_http::timeout::TimeoutLayer;
use tower_http::trace::TraceLayer;
use crate::api::JsonRpcHandler;
use crate::rpc_handler::RpcHandler;
use crate::{ServerConfig, rpc_handler};
pub type StarknetDevnetServer = axum::serve::Serve<TcpListener, IntoMakeService<Router>, Router>;
fn json_rpc_routes<TJsonRpcHandler: RpcHandler>(json_rpc_handler: TJsonRpcHandler) -> Router {
Router::new()
.route("/", post(rpc_handler::handle::<TJsonRpcHandler>))
.route("/rpc", post(rpc_handler::handle::<TJsonRpcHandler>))
.route("/ws", get(rpc_handler::handle_socket::<TJsonRpcHandler>))
.with_state(json_rpc_handler)
}
/// Configures an [axum::Server] that handles related JSON-RPC calls and web API calls via HTTP.
pub async fn serve_http_json_rpc(
tcp_listener: TcpListener,
server_config: &ServerConfig,
json_rpc_handler: JsonRpcHandler,
) -> StarknetDevnetServer {
let mut routes = Router::new()
.route("/is_alive", get(|| async { "Alive!!!" })) // Only REST endpoint to simplify liveness probe
.merge(json_rpc_routes(json_rpc_handler.clone()))
.layer(TraceLayer::new_for_http());
if server_config.log_response {
routes = routes.layer(axum::middleware::from_fn(response_logging_middleware));
};
routes = routes
.layer(TimeoutLayer::with_status_code(
StatusCode::REQUEST_TIMEOUT,
Duration::from_secs(server_config.timeout.into()),
))
.layer(DefaultBodyLimit::disable())
.layer(
// More details: https://docs.rs/tower-http/latest/tower_http/cors/index.html
CorsLayer::new()
.allow_origin(HeaderValue::from_static("*"))
.allow_headers(vec![header::CONTENT_TYPE])
.allow_methods(vec![Method::GET, Method::POST]),
);
if server_config.log_request {
routes = routes.layer(axum::middleware::from_fn(request_logging_middleware));
}
axum::serve(tcp_listener, routes.into_make_service())
}
async fn log_body_and_path<T>(
body: T,
uri_option: Option<axum::http::Uri>,
) -> Result<axum::body::Body, (StatusCode, String)>
where
T: axum::body::HttpBody<Data = Bytes>,
T::Error: std::fmt::Display,
{
let bytes = match body.collect().await {
Ok(collected) => collected.to_bytes(),
Err(err) => {
return Err((StatusCode::INTERNAL_SERVER_ERROR, err.to_string()));
}
};
if let Ok(body_str) = std::str::from_utf8(&bytes) {
if let Some(uri) = uri_option {
tracing::info!("{} {}", uri, body_str);
} else {
tracing::info!("{}", body_str);
}
} else {
tracing::error!("Failed to convert body to string");
}
Ok(Body::from(bytes))
}
async fn request_logging_middleware(
request: Request,
next: Next,
) -> Result<impl IntoResponse, (StatusCode, String)> {
let (parts, body) = request.into_parts();
let body = log_body_and_path(body, Some(parts.uri.clone())).await?;
Ok(next.run(Request::from_parts(parts, body)).await)
}
async fn response_logging_middleware(
request: Request,
next: Next,
) -> Result<impl IntoResponse, (StatusCode, String)> {
let response = next.run(request).await;
let (parts, body) = response.into_parts();
let body = log_body_and_path(body, None).await?;
let response = Response::from_parts(parts, body);
Ok(response)
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/dump_util.rs | crates/starknet-devnet-server/src/dump_util.rs | use std::fs::{self, File, OpenOptions};
use std::io::{Read, Seek, SeekFrom, Write};
use std::path::Path;
use starknet_core::error::{DevnetResult, Error};
use starknet_core::starknet::starknet_config::DumpOn;
use crate::rpc_core::request::RpcMethodCall;
pub type DumpEvent = RpcMethodCall;
/// Saves Devnet `events` to the file at `path`. If `events` is empty, does nothing.
pub fn dump_events(events: &Vec<DumpEvent>, path: &str) -> DevnetResult<()> {
if !events.is_empty() {
let events_dump = serde_json::to_string(events)
.map_err(|e| Error::SerializationError { origin: e.to_string() })?;
fs::write(Path::new(&path), events_dump)?;
}
Ok(())
}
/// Attaches starknet event to the end of the file at `path`. If no file present, creates it.
pub fn dump_event(event: &DumpEvent, path: &str) -> DevnetResult<()> {
let file_path = Path::new(path);
if file_path.exists() {
// attach to file
let event_dump = serde_json::to_string(event)
.map_err(|e| Error::SerializationError { origin: e.to_string() })?;
let mut file =
OpenOptions::new().append(true).read(true).open(file_path).map_err(Error::IoError)?;
let mut buffer = [0; 1];
file.seek(SeekFrom::End(-1))?;
file.read_exact(&mut buffer)?;
if String::from_utf8_lossy(&buffer).into_owned() == "]" {
// if the last character is "]", remove it and add event at the end
let length = file.seek(SeekFrom::End(0)).map_err(Error::IoError)?;
file.set_len(length - 1).map_err(Error::IoError)?; // remove last "]" with set_len
file.write_all(format!(", {event_dump}]").as_bytes()).map_err(Error::IoError)?;
} else {
// if the last character is not "]" it means that it's a wrongly formatted
// file
return Err(Error::FormatError);
}
} else {
// create file
let events = vec![event];
let events_dump = serde_json::to_string(&events)
.map_err(|e| Error::SerializationError { origin: e.to_string() })?;
fs::write(Path::new(&path), events_dump)?;
}
Ok(())
}
/// Returns Devnet events from the provided `path`
pub fn load_events(dump_on: Option<DumpOn>, path: &str) -> DevnetResult<Vec<DumpEvent>> {
let file_path = Path::new(path);
if path.is_empty() || !file_path.exists() {
return Err(Error::FileNotFound);
}
let file = File::open(file_path).map_err(Error::IoError)?;
let events: Vec<DumpEvent> = serde_json::from_reader(file)
.map_err(|e| Error::DeserializationError { origin: e.to_string() })?;
// to avoid doublets in block mode during load, we need to remove the file
// because they will be re-executed and saved again
if let Some(DumpOn::Block) = dump_on {
// TODO refactor: this shouldn't be the responsibility of this method
fs::remove_file(file_path).map_err(Error::IoError)?;
}
Ok(events)
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/rpc_handler.rs | crates/starknet-devnet-server/src/rpc_handler.rs | use std::fmt::{self};
use axum::Json;
use axum::extract::rejection::JsonRejection;
use axum::extract::ws::WebSocket;
use axum::extract::{State, WebSocketUpgrade};
use axum::response::IntoResponse;
use futures::{FutureExt, future};
use serde::de::DeserializeOwned;
use tracing::{trace, warn};
use crate::rpc_core::error::RpcError;
use crate::rpc_core::request::{Request, RpcCall, RpcMethodCall};
use crate::rpc_core::response::{Response, ResponseResult, RpcResponse};
/// Helper trait that is used to execute starknet rpc calls
#[async_trait::async_trait]
pub trait RpcHandler: Clone + Send + Sync + 'static {
/// The request type to expect
type Request: DeserializeOwned + Send + Sync + fmt::Display;
/// Invoked when the request was received
async fn on_request(
&self,
request: Self::Request,
original_call: RpcMethodCall,
) -> ResponseResult;
/// Invoked for every incoming `RpcMethodCall`
///
/// This will attempt to deserialize a `{ "method" : "<name>", "params": "<params>" }` message
/// into the `Request` type of this handler. If a `Request` instance was deserialized
/// successfully, [`Self::on_request`] will be invoked.
///
/// **Note**: override this function if the expected `Request` deviates from `{ "method" :
/// "<name>", "params": "<params>" }`
async fn on_call(&self, call: RpcMethodCall) -> RpcResponse;
/// Handles websocket connection, from start to finish.
async fn on_websocket(&self, mut socket: WebSocket);
}
/// Handles incoming JSON-RPC Request
pub async fn handle<THandler: RpcHandler>(
State(handler): State<THandler>,
request: Result<Json<Request>, JsonRejection>,
) -> Json<Response> {
match request {
Ok(req) => handle_request(req.0, handler)
.await
.unwrap_or_else(|| Response::error(RpcError::invalid_request()))
.into(),
Err(err) => match &err {
JsonRejection::JsonSyntaxError(e) => {
let error_msg = e.to_string();
warn!(target: "rpc", "JSON syntax error: {}", error_msg);
Response::error(RpcError::parse_error(error_msg)).into()
}
JsonRejection::JsonDataError(e) => {
warn!(target: "rpc", "JSON data error: {}", e);
Response::error(RpcError::invalid_request_with_reason(format!("Data error: {}", e)))
.into()
}
JsonRejection::MissingJsonContentType(e) => {
warn!(target: "rpc", "Missing JSON content type: {}", e);
Response::error(RpcError::invalid_request_with_reason("Missing content type"))
.into()
}
_ => {
warn!(target: "rpc", "Request rejection: {}", err);
Response::error(RpcError::invalid_request_with_reason(err.to_string())).into()
}
},
}
}
pub async fn handle_socket<THandler: RpcHandler>(
ws_upgrade: WebSocketUpgrade,
State(handler): State<THandler>,
) -> impl IntoResponse {
tracing::info!("New websocket connection!");
ws_upgrade.on_failed_upgrade(|e| tracing::error!("Failed websocket upgrade: {e:?}")).on_upgrade(
move |socket| async move {
handler.on_websocket(socket).await;
},
)
}
/// Handle the JSON-RPC [Request]
///
/// This will try to deserialize the payload into the request type of the handler and if successful
/// invoke the handler.
pub async fn handle_request<THandler: RpcHandler>(
req: Request,
handler: THandler,
) -> Option<Response> {
/// processes batch calls
fn responses_as_batch(outs: Vec<Option<RpcResponse>>) -> Option<Response> {
let batch: Vec<_> = outs.into_iter().flatten().collect();
(!batch.is_empty()).then_some(Response::Batch(batch))
}
match req {
Request::Single(call) => handle_call(call, handler).await.map(Response::Single),
Request::Batch(calls) => {
future::join_all(calls.into_iter().map(move |call| handle_call(call, handler.clone())))
.map(responses_as_batch)
.await
}
}
}
/// handle a single RPC method call
pub(crate) async fn handle_call<THandler: RpcHandler>(
call: RpcCall,
handler: THandler,
) -> Option<RpcResponse> {
match call {
RpcCall::MethodCall(call) => {
trace!(target: "rpc", id = ?call.id, method = ?call.method, "handling call");
Some(handler.on_call(call).await)
}
RpcCall::Notification(notification) => {
trace!(target: "rpc", method = ?notification.method, "received rpc notification");
None
}
RpcCall::Invalid { id } => {
warn!(target: "rpc", ?id, "invalid rpc call");
Some(RpcResponse::invalid_request(id))
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/endpoints_ws.rs | crates/starknet-devnet-server/src/api/endpoints_ws.rs | use starknet_core::error::Error;
use starknet_rs_core::types::{
BlockId as ImportedBlockId, Felt, L1DataAvailabilityMode as ImportedL1DataAvailabilityMode,
MaybePreConfirmedBlockWithTxHashes,
};
use starknet_rs_providers::{Provider, ProviderError};
use starknet_types::contract_address::ContractAddress;
use starknet_types::emitted_event::{EmittedEvent, SubscriptionEmittedEvent};
use starknet_types::felt::TransactionHash;
use starknet_types::rpc::block::{BlockHeader, BlockId, BlockStatus, BlockTag};
use starknet_types::rpc::transactions::TransactionFinalityStatus;
use starknet_types::starknet_api::block::{BlockNumber, BlockTimestamp};
use starknet_types::starknet_api::core::{
EventCommitment, ReceiptCommitment, StateDiffCommitment, TransactionCommitment,
};
use starknet_types::starknet_api::data_availability::L1DataAvailabilityMode;
use starknet_types::starknet_api::hash::PoseidonHash;
use super::JsonRpcHandler;
use super::error::ApiError;
use super::models::{
EventsSubscriptionInput, SubscriptionBlockIdInput, SubscriptionIdInput, TransactionHashInput,
TransactionReceiptSubscriptionInput, TransactionSubscriptionInput,
};
use crate::api::models::JsonRpcSubscriptionRequest;
use crate::rpc_core::request::Id;
use crate::subscribe::{
AddressFilter, NewTransactionStatus, NotificationData, SocketId, StatusFilter, Subscription,
};
/// The definitions of JSON-RPC read endpoints defined in starknet_ws_api.json
impl JsonRpcHandler {
pub async fn execute_ws_subscription(
&self,
request: JsonRpcSubscriptionRequest,
rpc_request_id: Id,
socket_id: SocketId,
) -> Result<(), ApiError> {
match request {
JsonRpcSubscriptionRequest::NewHeads(data) => {
self.subscribe_new_heads(data, rpc_request_id, socket_id).await
}
JsonRpcSubscriptionRequest::TransactionStatus(TransactionHashInput {
transaction_hash,
}) => self.subscribe_tx_status(transaction_hash, rpc_request_id, socket_id).await,
JsonRpcSubscriptionRequest::NewTransactions(data) => {
self.subscribe_new_txs(data, rpc_request_id, socket_id).await
}
JsonRpcSubscriptionRequest::NewTransactionReceipts(data) => {
self.subscribe_new_tx_receipts(data, rpc_request_id, socket_id).await
}
JsonRpcSubscriptionRequest::Events(data) => {
self.subscribe_events(data, rpc_request_id, socket_id).await
}
JsonRpcSubscriptionRequest::Unsubscribe(SubscriptionIdInput { subscription_id }) => {
let mut sockets = self.api.sockets.lock().await;
let socket_context = sockets.get_mut(&socket_id)?;
socket_context.unsubscribe(rpc_request_id, subscription_id).await
}
}
}
async fn get_origin_block_header_by_id(&self, id: BlockId) -> Result<BlockHeader, ApiError> {
let origin_caller = self.origin_caller.as_ref().ok_or_else(|| {
ApiError::StarknetDevnetError(Error::UnexpectedInternalError {
msg: "No origin caller available".into(),
})
})?;
match origin_caller
.starknet_client
.get_block_with_tx_hashes(ImportedBlockId::from(id))
.await
{
Ok(MaybePreConfirmedBlockWithTxHashes::Block(origin_block)) => {
let origin_header = BlockHeader {
block_hash: origin_block.block_hash,
parent_hash: origin_block.parent_hash,
block_number: BlockNumber(origin_block.block_number),
l1_gas_price: origin_block.l1_gas_price.into(),
l2_gas_price: origin_block.l2_gas_price.into(),
new_root: origin_block.new_root,
sequencer_address: ContractAddress::new_unchecked(
origin_block.sequencer_address,
),
timestamp: BlockTimestamp(origin_block.timestamp),
starknet_version: origin_block.starknet_version,
l1_data_gas_price: origin_block.l1_data_gas_price.into(),
l1_da_mode: match origin_block.l1_da_mode {
ImportedL1DataAvailabilityMode::Calldata => {
L1DataAvailabilityMode::Calldata
}
ImportedL1DataAvailabilityMode::Blob => L1DataAvailabilityMode::Blob,
},
n_transactions: origin_block.transaction_count,
n_events: origin_block.event_count,
state_diff_length: origin_block.state_diff_length,
state_diff_commitment: StateDiffCommitment(PoseidonHash(
origin_block.state_diff_commitment,
)),
transaction_commitment: TransactionCommitment(
origin_block.transaction_commitment,
),
event_commitment: EventCommitment(origin_block.event_commitment),
receipt_commitment: ReceiptCommitment(origin_block.receipt_commitment),
};
Ok(origin_header)
}
Err(ProviderError::StarknetError(
starknet_rs_core::types::StarknetError::BlockNotFound,
)) => Err(ApiError::BlockNotFound),
other => Err(ApiError::StarknetDevnetError(
starknet_core::error::Error::UnexpectedInternalError {
msg: format!("Failed retrieval of block from forking origin. Got: {other:?}"),
},
)),
}
}
async fn get_local_block_header_by_id(&self, id: &BlockId) -> Result<BlockHeader, ApiError> {
let starknet = self.api.starknet.lock().await;
let block = match starknet.get_block(id) {
Ok(block) => match block.status() {
BlockStatus::Rejected => return Err(ApiError::BlockNotFound),
_ => Ok::<_, ApiError>(block),
},
Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
Err(other) => Err(ApiError::StarknetDevnetError(other)),
}?;
Ok(block.into())
}
/// Returns (starting block number, latest block number). Returns an error in case the starting
/// block does not exist or there are too many blocks.
async fn get_validated_block_number_range(
&self,
mut starting_block_id: BlockId,
) -> Result<(u64, u64, Option<(u64, u64)>), ApiError> {
// Convert pre-confirmed to latest to prevent getting block_number = 0
starting_block_id = match starting_block_id {
BlockId::Tag(BlockTag::PreConfirmed) => BlockId::Tag(BlockTag::Latest),
other => other,
};
let query_block_number = match starting_block_id {
BlockId::Number(n) => n,
block_id => match self.get_local_block_header_by_id(&block_id).await {
Ok(block) => block.block_number.0,
Err(ApiError::BlockNotFound) if self.origin_caller.is_some() => {
self.get_origin_block_header_by_id(block_id).await?.block_number.0
}
Err(other) => return Err(other),
},
};
let starknet = self.api.starknet.lock().await;
let latest_block_number =
starknet.get_block(&BlockId::Tag(BlockTag::Latest))?.block_number().0;
drop(starknet);
let (fork_url, fork_block_number) =
(self.api.config.fork_config.url.clone(), self.api.config.fork_config.block_number);
if query_block_number > latest_block_number {
return Err(ApiError::BlockNotFound);
}
if latest_block_number - query_block_number > 1024 {
return Err(ApiError::TooManyBlocksBack);
}
// Check if forking is configured and return the block range from the forking origin
let origin_block_range = match (fork_url, fork_block_number) {
(Some(_url), Some(fork_block_number)) => {
// If the query block number is less than or equal to the fork block number,
// we need to fetch blocks from the origin
if query_block_number <= fork_block_number {
Some((query_block_number, fork_block_number))
} else {
None
}
}
_ => None, // No fork configuration or block number
};
let validated_start_block_number =
if let Some(origin) = origin_block_range { origin.1 + 1 } else { query_block_number };
Ok((validated_start_block_number, latest_block_number, origin_block_range))
}
async fn fetch_origin_heads(
&self,
start_block: u64,
end_block: u64,
) -> Result<Vec<BlockHeader>, ApiError> {
let mut headers = Vec::new();
for block_n in start_block..=end_block {
let block_id = BlockId::Number(block_n);
headers.push(self.get_origin_block_header_by_id(block_id).await?);
}
Ok(headers)
}
/// starknet_subscribeNewHeads
/// Checks if an optional block ID is provided. Validates that the block exists and is not too
/// many blocks in the past. If it is a valid block, the user is notified of all blocks from the
/// old up to the latest, and subscribed to new ones. If no block ID specified, the user is just
/// subscribed to new blocks.
async fn subscribe_new_heads(
&self,
block_input: Option<SubscriptionBlockIdInput>,
rpc_request_id: Id,
socket_id: SocketId,
) -> Result<(), ApiError> {
let block_id = if let Some(SubscriptionBlockIdInput { block_id }) = block_input {
block_id.into()
} else {
// if no block ID input, this eventually just subscribes the user to new blocks
BlockId::Tag(BlockTag::Latest)
};
let (query_block_number, latest_block_number, origin_range) =
self.get_validated_block_number_range(block_id).await?;
// perform the actual subscription
let mut sockets = self.api.sockets.lock().await;
let socket_context = sockets.get_mut(&socket_id)?;
let subscription_id =
socket_context.subscribe(rpc_request_id, Subscription::NewHeads).await;
if let BlockId::Tag(_) = block_id {
// if the specified block ID is a tag (i.e. latest/pre-confirmed), no old block handling
return Ok(());
}
let mut headers = Vec::new();
if let Some((origin_start, origin_end)) = origin_range {
// It's better to fetch all origin headers first, in case fetching some fetching fails
// halfway through notifying the socket
let origin_headers = self.fetch_origin_heads(origin_start, origin_end).await?;
headers.extend(origin_headers.iter().cloned());
}
// Notifying of old blocks. latest_block_number inclusive?
// Yes, only if block_id != latest/pre-confirmed (handled above)
let starknet = self.api.starknet.lock().await;
for block_n in query_block_number..=latest_block_number {
let old_block = starknet
.get_block(&BlockId::Number(block_n))
.map_err(ApiError::StarknetDevnetError)?;
headers.push(old_block.into());
}
for header in headers {
let notification = NotificationData::NewHeads(header);
socket_context.notify(subscription_id, notification).await;
}
Ok(())
}
/// Does not return TOO_MANY_ADDRESSES_IN_FILTER
pub async fn subscribe_new_txs(
&self,
maybe_subscription_input: Option<TransactionSubscriptionInput>,
rpc_request_id: Id,
socket_id: SocketId,
) -> Result<(), ApiError> {
let status_filter = StatusFilter::new(
maybe_subscription_input
.as_ref()
.and_then(|input| input.finality_status.as_ref())
.map_or_else(
|| vec![TransactionFinalityStatus::AcceptedOnL2],
|statuses| {
statuses.iter().cloned().map(TransactionFinalityStatus::from).collect()
},
),
);
let address_filter = AddressFilter::new(
maybe_subscription_input
.and_then(|subscription_input| subscription_input.sender_address)
.unwrap_or_default(),
);
let mut sockets = self.api.sockets.lock().await;
let socket_context = sockets.get_mut(&socket_id)?;
let subscription = Subscription::NewTransactions { address_filter, status_filter };
socket_context.subscribe(rpc_request_id, subscription).await;
Ok(())
}
/// Does not return TOO_MANY_ADDRESSES_IN_FILTER
pub async fn subscribe_new_tx_receipts(
&self,
maybe_subscription_input: Option<TransactionReceiptSubscriptionInput>,
rpc_request_id: Id,
socket_id: SocketId,
) -> Result<(), ApiError> {
let status_filter = StatusFilter::new(
maybe_subscription_input
.as_ref()
.and_then(|input| input.finality_status.as_ref())
.map_or_else(
|| vec![TransactionFinalityStatus::AcceptedOnL2],
|statuses| {
statuses.iter().cloned().map(TransactionFinalityStatus::from).collect()
},
),
);
let address_filter = AddressFilter::new(
maybe_subscription_input
.and_then(|subscription_input| subscription_input.sender_address)
.unwrap_or_default(),
);
let mut sockets = self.api.sockets.lock().await;
let socket_context = sockets.get_mut(&socket_id)?;
let subscription = Subscription::NewTransactionReceipts { address_filter, status_filter };
socket_context.subscribe(rpc_request_id, subscription).await;
Ok(())
}
async fn subscribe_tx_status(
&self,
transaction_hash: TransactionHash,
rpc_request_id: Id,
socket_id: SocketId,
) -> Result<(), ApiError> {
// perform the actual subscription
let mut sockets = self.api.sockets.lock().await;
let socket_context = sockets.get_mut(&socket_id)?;
let subscription = Subscription::TransactionStatus { transaction_hash };
let subscription_id = socket_context.subscribe(rpc_request_id, subscription).await;
let starknet = self.api.starknet.lock().await;
if let Some(tx) = starknet.transactions.get(&transaction_hash) {
let notification = NotificationData::TransactionStatus(NewTransactionStatus {
transaction_hash,
status: tx.get_status(),
});
socket_context.notify(subscription_id, notification).await;
} else {
tracing::debug!("Tx status subscription: tx not yet received")
}
Ok(())
}
async fn fetch_origin_events(
&self,
from_block: u64,
to_block: u64,
address: Option<ContractAddress>,
keys_filter: Option<Vec<Vec<Felt>>>,
) -> Result<Vec<EmittedEvent>, ApiError> {
const DEFAULT_CHUNK_SIZE: u64 = 1000;
let mut continuation_token: Option<String> = None;
let mut all_events = Vec::new();
// Fetch all events with pagination
loop {
let events_chunk = self
.fetch_origin_events_chunk(
from_block,
to_block,
continuation_token,
address,
keys_filter.clone(),
DEFAULT_CHUNK_SIZE,
)
.await?;
// Extend our collection with events from this chunk
all_events.extend(events_chunk.events);
// Update continuation token or break if done
match events_chunk.continuation_token {
Some(token) if token == "0" => break,
Some(token) => continuation_token = Some(token),
None => break,
}
}
Ok(all_events)
}
async fn subscribe_events(
&self,
maybe_subscription_input: Option<EventsSubscriptionInput>,
rpc_request_id: Id,
socket_id: SocketId,
) -> Result<(), ApiError> {
let address = maybe_subscription_input
.as_ref()
.and_then(|subscription_input| subscription_input.from_address);
let starting_block_id = maybe_subscription_input
.as_ref()
.and_then(|subscription_input| subscription_input.block_id.as_ref().map(BlockId::from))
.unwrap_or(BlockId::Tag(BlockTag::Latest));
let (validated_start_block_number, _, origin_range) =
self.get_validated_block_number_range(starting_block_id).await?;
let keys_filter = maybe_subscription_input
.as_ref()
.and_then(|subscription_input| subscription_input.keys.clone());
let finality_status = maybe_subscription_input
.and_then(|subscription_input| subscription_input.finality_status)
.unwrap_or(TransactionFinalityStatus::AcceptedOnL2);
let mut sockets = self.api.sockets.lock().await;
let socket_context = sockets.get_mut(&socket_id)?;
let subscription = Subscription::Events {
address,
keys_filter: keys_filter.clone(),
status_filter: StatusFilter::new(vec![finality_status]),
};
let subscription_id = socket_context.subscribe(rpc_request_id, subscription).await;
// Fetch events from origin chain if we're in a fork and need historical data
let origin_events = if let Some((origin_start, origin_end)) = origin_range {
Some(
self.fetch_origin_events(origin_start, origin_end, address, keys_filter.clone())
.await?,
)
} else {
None
};
// Get events from local chain
let local_events = self.api.starknet.lock().await.get_unlimited_events(
Some(BlockId::Number(validated_start_block_number)),
Some(BlockId::Tag(BlockTag::PreConfirmed)), // Last block; filtering by status
address,
keys_filter,
Some(finality_status),
)?;
// Process origin events first (chronological order)
if let Some(origin_events) = origin_events {
for event in origin_events {
let notification_data = NotificationData::Event(SubscriptionEmittedEvent {
emitted_event: event,
finality_status,
});
socket_context.notify(subscription_id, notification_data).await;
}
}
// Process local events after origin events
for event in local_events {
let notification_data = NotificationData::Event(SubscriptionEmittedEvent {
emitted_event: event,
finality_status,
});
socket_context.notify(subscription_id, notification_data).await;
}
Ok(())
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/endpoints.rs | crates/starknet-devnet-server/src/api/endpoints.rs | use starknet_core::error::{ContractExecutionError, Error, StateError};
use starknet_rs_core::types::{BlockId as ImportedBlockId, Felt, MsgFromL1};
use starknet_rs_providers::Provider;
use starknet_types::contract_address::ContractAddress;
use starknet_types::felt::{ClassHash, TransactionHash};
use starknet_types::patricia_key::PatriciaKey;
use starknet_types::rpc::block::{
Block, BlockHeader, BlockId, BlockResult, BlockStatus, BlockTag, PreConfirmedBlock,
PreConfirmedBlockHeader,
};
use starknet_types::rpc::state::StateUpdateResult;
use starknet_types::rpc::transaction_receipt::FeeUnit;
use starknet_types::rpc::transactions::{
BroadcastedTransaction, EventFilter, EventsChunk, FunctionCall, SimulationFlag, Transactions,
};
use super::error::{ApiError, StrictRpcResult};
use super::models::{
BlockHashAndNumberOutput, GetStorageProofInput, L1TransactionHashInput, SyncingOutput,
};
use crate::api::account_helpers::{
BalanceQuery, PredeployedAccountsQuery, get_balance, get_balance_unit,
get_erc20_fee_unit_address,
};
use crate::api::models::{
AccountBalanceResponse, AccountBalancesResponse, DevnetResponse, SerializableAccount,
StarknetResponse,
};
use crate::api::{JsonRpcHandler, RPC_SPEC_VERSION};
use crate::config::DevnetConfig;
const DEFAULT_CONTINUATION_TOKEN: &str = "0";
const CONTINUATION_TOKEN_ORIGIN_PREFIX: &str = "devnet-origin-";
/// The definitions of JSON-RPC read endpoints defined in starknet_api_openrpc.json
impl JsonRpcHandler {
/// starknet_specVersion
pub fn spec_version(&self) -> StrictRpcResult {
Ok(StarknetResponse::String(RPC_SPEC_VERSION.to_string()).into())
}
/// starknet_getBlockWithTxHashes
pub async fn get_block_with_tx_hashes(&self, block_id: BlockId) -> StrictRpcResult {
let starknet = self.api.starknet.lock().await;
let block = starknet.get_block(&block_id).map_err(|err| match err {
Error::NoBlock => ApiError::BlockNotFound,
unknown_error => ApiError::StarknetDevnetError(unknown_error),
})?;
let transactions = Transactions::Hashes(block.get_transactions().to_owned());
Ok(match block.status() {
BlockStatus::PreConfirmed => StarknetResponse::PreConfirmedBlock(PreConfirmedBlock {
header: PreConfirmedBlockHeader::from(block),
transactions,
}),
_ => StarknetResponse::Block(Block {
status: *block.status(),
header: BlockHeader::from(block),
transactions,
}),
}
.into())
}
/// starknet_getBlockWithTxs
pub async fn get_block_with_txs(&self, block_id: BlockId) -> StrictRpcResult {
let block = self.api.starknet.lock().await.get_block_with_transactions(&block_id).map_err(
|err| match err {
Error::NoBlock => ApiError::BlockNotFound,
Error::NoTransaction => ApiError::TransactionNotFound,
unknown_error => ApiError::StarknetDevnetError(unknown_error),
},
)?;
match block {
BlockResult::Block(b) => Ok(StarknetResponse::Block(b).into()),
BlockResult::PreConfirmedBlock(b) => Ok(StarknetResponse::PreConfirmedBlock(b).into()),
}
}
/// starknet_getBlockWithReceipts
pub async fn get_block_with_receipts(&self, block_id: BlockId) -> StrictRpcResult {
let block = self.api.starknet.lock().await.get_block_with_receipts(&block_id).map_err(
|e| match e {
Error::NoBlock => ApiError::BlockNotFound,
Error::NoTransaction => ApiError::TransactionNotFound,
unknown_error => ApiError::StarknetDevnetError(unknown_error),
},
)?;
match block {
BlockResult::Block(b) => Ok(StarknetResponse::Block(b).into()),
BlockResult::PreConfirmedBlock(b) => Ok(StarknetResponse::PreConfirmedBlock(b).into()),
}
}
/// starknet_getStateUpdate
pub async fn get_state_update(&self, block_id: BlockId) -> StrictRpcResult {
let state_update =
self.api.starknet.lock().await.block_state_update(&block_id).map_err(|e| match e {
Error::NoBlock => ApiError::BlockNotFound,
unknown_error => ApiError::StarknetDevnetError(unknown_error),
})?;
match state_update {
StateUpdateResult::StateUpdate(s) => Ok(StarknetResponse::StateUpdate(s).into()),
StateUpdateResult::PreConfirmedStateUpdate(s) => {
Ok(StarknetResponse::PreConfirmedStateUpdate(s).into())
}
}
}
/// starknet_getStorageAt
pub async fn get_storage_at(
&self,
contract_address: ContractAddress,
key: PatriciaKey,
block_id: BlockId,
) -> StrictRpcResult {
let felt = self
.api
.starknet
.lock()
.await
.contract_storage_at_block(&block_id, contract_address, key)
.map_err(|err| match err {
Error::NoBlock => ApiError::BlockNotFound,
Error::ContractNotFound | Error::StateError(StateError::NoneStorage(_)) => {
ApiError::ContractNotFound
}
e @ Error::NoStateAtBlock { .. } => ApiError::NoStateAtBlock { msg: e.to_string() },
unknown_error => ApiError::StarknetDevnetError(unknown_error),
})?;
Ok(StarknetResponse::Felt(felt).into())
}
/// starknet_getStorageProof
pub async fn get_storage_proof(&self, data: GetStorageProofInput) -> StrictRpcResult {
match self.api.starknet.lock().await.get_block(&data.block_id) {
// storage proofs not applicable to Devnet
Ok(_) => Err(ApiError::StorageProofNotSupported),
Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
Err(unknown_error) => Err(ApiError::StarknetDevnetError(unknown_error)),
}
}
/// starknet_getTransactionByHash
pub async fn get_transaction_by_hash(
&self,
transaction_hash: TransactionHash,
) -> StrictRpcResult {
match self.api.starknet.lock().await.get_transaction_by_hash(transaction_hash) {
Ok(transaction) => Ok(StarknetResponse::Transaction(transaction.clone()).into()),
Err(Error::NoTransaction) => Err(ApiError::TransactionNotFound),
Err(err) => Err(err.into()),
}
}
/// starknet_getTransactionStatus
pub async fn get_transaction_status_by_hash(
&self,
transaction_hash: TransactionHash,
) -> StrictRpcResult {
match self
.api
.starknet
.lock()
.await
.get_transaction_execution_and_finality_status(transaction_hash)
{
Ok(tx_status) => Ok(StarknetResponse::TransactionStatusByHash(tx_status).into()),
Err(Error::NoTransaction) => Err(ApiError::TransactionNotFound),
Err(err) => Err(err.into()),
}
}
/// starknet_getTransactionByBlockIdAndIndex
pub async fn get_transaction_by_block_id_and_index(
&self,
block_id: BlockId,
index: u64,
) -> StrictRpcResult {
match self.api.starknet.lock().await.get_transaction_by_block_id_and_index(&block_id, index)
{
Ok(transaction) => Ok(StarknetResponse::Transaction(transaction.clone()).into()),
Err(Error::InvalidTransactionIndexInBlock) => {
Err(ApiError::InvalidTransactionIndexInBlock)
}
Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
Err(unknown_error) => Err(ApiError::StarknetDevnetError(unknown_error)),
}
}
/// starknet_getTransactionReceipt
pub async fn get_transaction_receipt_by_hash(
&self,
transaction_hash: TransactionHash,
) -> StrictRpcResult {
match self.api.starknet.lock().await.get_transaction_receipt_by_hash(&transaction_hash) {
Ok(receipt) => {
Ok(StarknetResponse::TransactionReceiptByTransactionHash(Box::new(receipt)).into())
}
Err(Error::NoTransaction) => Err(ApiError::TransactionNotFound),
Err(err) => Err(err.into()),
}
}
/// starknet_getClass
pub async fn get_class(&self, block_id: BlockId, class_hash: ClassHash) -> StrictRpcResult {
match self.api.starknet.lock().await.get_class(&block_id, class_hash) {
Ok(contract_class) => {
Ok(StarknetResponse::ContractClass(contract_class.try_into()?).into())
}
Err(e) => Err(match e {
Error::NoBlock => ApiError::BlockNotFound,
Error::StateError(_) => ApiError::ClassHashNotFound,
e @ Error::NoStateAtBlock { .. } => ApiError::NoStateAtBlock { msg: e.to_string() },
unknown_error => ApiError::StarknetDevnetError(unknown_error),
}),
}
}
/// starknet_getCompiledCasm
pub async fn get_compiled_casm(&self, class_hash: ClassHash) -> StrictRpcResult {
// starknet_getCompiledCasm compiles sierra to casm the same way it is done in
// starknet_addDeclareTransaction, so if during starknet_addDeclareTransaction compilation
// does not fail, so it will not fail during this endpoint execution
match self.api.starknet.lock().await.get_compiled_casm(class_hash) {
Ok(compiled_casm) => Ok(StarknetResponse::CompiledCasm(compiled_casm).into()),
Err(e) => Err(match e {
Error::NoBlock => ApiError::BlockNotFound,
Error::StateError(_) => ApiError::ClassHashNotFound,
e @ Error::NoStateAtBlock { .. } => ApiError::NoStateAtBlock { msg: e.to_string() },
unknown_error => ApiError::StarknetDevnetError(unknown_error),
}),
}
}
/// starknet_getClassAt
pub async fn get_class_at(
&self,
block_id: BlockId,
contract_address: ContractAddress,
) -> StrictRpcResult {
match self.api.starknet.lock().await.get_class_at(&block_id, contract_address) {
Ok(contract_class) => {
Ok(StarknetResponse::ContractClass(contract_class.try_into()?).into())
}
Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
Err(Error::StateError(StateError::NoneClassHash(_))) => {
// NoneClassHash can be returned only when forking, otherwise it means that
// contract_address is locally present, but its class hash isn't, which is a bug.
// ClassHashNotFound is not expected to be returned by the server, but to be handled
// by the forking logic as a signal to forward the request to the origin.
Err(ApiError::ClassHashNotFound)
}
Err(Error::ContractNotFound | Error::StateError(_)) => Err(ApiError::ContractNotFound),
Err(e @ Error::NoStateAtBlock { .. }) => {
Err(ApiError::NoStateAtBlock { msg: e.to_string() })
}
Err(unknown_error) => Err(ApiError::StarknetDevnetError(unknown_error)),
}
}
/// starknet_getClassHashAt
pub async fn get_class_hash_at(
&self,
block_id: BlockId,
contract_address: ContractAddress,
) -> StrictRpcResult {
match self.api.starknet.lock().await.get_class_hash_at(&block_id, contract_address) {
Ok(class_hash) => Ok(StarknetResponse::Felt(class_hash).into()),
Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
Err(Error::ContractNotFound) => Err(ApiError::ContractNotFound),
Err(e @ Error::NoStateAtBlock { .. }) => {
Err(ApiError::NoStateAtBlock { msg: e.to_string() })
}
Err(unknown_error) => Err(ApiError::StarknetDevnetError(unknown_error)),
}
}
/// starknet_getBlockTransactionCount
pub async fn get_block_txs_count(&self, block_id: BlockId) -> StrictRpcResult {
let num_trans_count = self.api.starknet.lock().await.get_block_txs_count(&block_id);
match num_trans_count {
Ok(count) => Ok(StarknetResponse::BlockTransactionCount(count).into()),
Err(_) => Err(ApiError::BlockNotFound),
}
}
/// starknet_call
pub async fn call(&self, block_id: BlockId, request: FunctionCall) -> StrictRpcResult {
match self.api.starknet.lock().await.call(
&block_id,
request.contract_address.into(),
request.entry_point_selector,
request.calldata,
) {
Ok(result) => Ok(StarknetResponse::Call(result).into()),
Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
Err(Error::ContractNotFound) => Err(ApiError::ContractNotFound),
Err(Error::EntrypointNotFound) => Err(ApiError::EntrypointNotFound),
Err(e @ Error::NoStateAtBlock { .. }) => {
Err(ApiError::NoStateAtBlock { msg: e.to_string() })
}
Err(Error::ContractExecutionError(execution_error)) => {
Err(ApiError::ContractError(execution_error))
}
Err(e) => Err(ApiError::ContractError(ContractExecutionError::Message(e.to_string()))),
}
}
/// starknet_estimateFee
pub async fn estimate_fee(
&self,
block_id: BlockId,
request: Vec<BroadcastedTransaction>,
simulation_flags: Vec<SimulationFlag>,
) -> StrictRpcResult {
match self.api.starknet.lock().await.estimate_fee(&block_id, &request, &simulation_flags) {
Ok(result) => Ok(StarknetResponse::EstimateFee(result).into()),
Err(Error::ContractNotFound) => Err(ApiError::ContractNotFound),
Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
Err(e @ Error::NoStateAtBlock { .. }) => {
Err(ApiError::NoStateAtBlock { msg: e.to_string() })
}
Err(Error::ContractExecutionErrorInSimulation { failure_index, execution_error }) => {
Err(ApiError::TransactionExecutionError { failure_index, execution_error })
}
Err(e) => Err(ApiError::ContractError(ContractExecutionError::from(e.to_string()))),
}
}
pub async fn estimate_message_fee(
&self,
block_id: &BlockId,
message: MsgFromL1,
) -> StrictRpcResult {
match self.api.starknet.lock().await.estimate_message_fee(block_id, message) {
Ok(result) => Ok(StarknetResponse::EstimateMessageFee(result).into()),
Err(Error::ContractNotFound) => Err(ApiError::ContractNotFound),
Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
Err(e @ Error::NoStateAtBlock { .. }) => {
Err(ApiError::NoStateAtBlock { msg: e.to_string() })
}
Err(Error::ContractExecutionError(error)) => Err(ApiError::ContractError(error)),
Err(e) => Err(ApiError::ContractError(ContractExecutionError::from(e.to_string()))),
}
}
/// starknet_blockNumber
pub async fn block_number(&self) -> StrictRpcResult {
let block = self.api.starknet.lock().await.get_latest_block().map_err(|err| match err {
Error::NoBlock => ApiError::BlockNotFound,
unknown_error => ApiError::StarknetDevnetError(unknown_error),
})?;
Ok(StarknetResponse::BlockNumber(block.block_number()).into())
}
/// starknet_blockHashAndNumber
pub async fn block_hash_and_number(&self) -> StrictRpcResult {
let block = self.api.starknet.lock().await.get_latest_block().map_err(|err| match err {
Error::NoBlock => ApiError::BlockNotFound,
unknown_error => ApiError::StarknetDevnetError(unknown_error),
})?;
Ok(StarknetResponse::BlockHashAndNumber(BlockHashAndNumberOutput {
block_hash: block.block_hash(),
block_number: block.block_number(),
})
.into())
}
/// starknet_chainId
pub async fn chain_id(&self) -> StrictRpcResult {
let chain_id = self.api.starknet.lock().await.chain_id();
Ok(StarknetResponse::Felt(chain_id.to_felt()).into())
}
/// starknet_syncing
pub async fn syncing(&self) -> StrictRpcResult {
Ok(StarknetResponse::Syncing(SyncingOutput::False(false)).into())
}
/// Split into origin and local block ranges (non overlapping, local continuing onto origin)
/// Returns: (origin_range, local_start, local_end)
/// All ranges inclusive
async fn split_block_range(
&self,
from_block: Option<BlockId>,
to_block: Option<BlockId>,
) -> Result<(Option<(u64, u64)>, Option<BlockId>, Option<BlockId>), ApiError> {
let origin_caller = match &self.origin_caller {
Some(origin_caller) => origin_caller,
None => return Ok((None, from_block, to_block)),
};
let fork_block_number = origin_caller.fork_block_number();
let starknet = self.api.starknet.lock().await;
let from_block_number = match from_block {
Some(BlockId::Tag(BlockTag::Latest | BlockTag::PreConfirmed)) => {
return Ok((None, from_block, to_block));
}
Some(block_id @ (BlockId::Tag(BlockTag::L1Accepted) | BlockId::Hash(_))) => {
match starknet.get_block(&block_id) {
Ok(block) => block.block_number().0,
Err(_) => origin_caller.get_block_number_from_block_id(block_id).await?,
}
}
Some(BlockId::Number(from_block_number)) => from_block_number,
None => 0, // If no from_block, all blocks before to_block should be queried
};
if from_block_number > fork_block_number {
// Only local blocks need to be searched
return Ok((None, Some(BlockId::Number(from_block_number)), to_block));
}
let to_block_number = match to_block {
// If to_block is latest, pre_confirmed or undefined, all blocks after from_block are
// queried
Some(BlockId::Tag(BlockTag::Latest | BlockTag::PreConfirmed)) | None => {
return Ok((
Some((from_block_number, fork_block_number)),
// there is for sure at least one local block
Some(BlockId::Number(fork_block_number + 1)),
to_block,
));
}
Some(block_id @ (BlockId::Tag(BlockTag::L1Accepted) | BlockId::Hash(_))) => {
match starknet.get_block(&block_id) {
Ok(block) => block.block_number().0,
Err(_) => origin_caller.get_block_number_from_block_id(block_id).await?,
}
}
Some(BlockId::Number(to_block_number)) => to_block_number,
};
let origin_range = Some((from_block_number, to_block_number));
Ok(if to_block_number <= fork_block_number {
(origin_range, None, None)
} else {
(
origin_range,
Some(BlockId::Number(fork_block_number + 1)),
Some(BlockId::Number(to_block_number)),
)
})
}
/// Fetches events from forking origin. The continuation token should be the same as received by
/// Devnet (not yet adapted for origin). If more events can be fetched from the origin, this is
/// noted in the `continuation_token` of the returned `EventsChunk`.
pub(crate) async fn fetch_origin_events_chunk(
&self,
from_origin: u64,
to_origin: u64,
continuation_token: Option<String>,
address: Option<ContractAddress>,
keys: Option<Vec<Vec<Felt>>>,
chunk_size: u64,
) -> Result<EventsChunk, ApiError> {
let origin_caller = self.origin_caller.as_ref().ok_or(ApiError::StarknetDevnetError(
Error::UnexpectedInternalError { msg: "Origin caller unexpectedly undefined".into() },
))?;
let origin_continuation_token = continuation_token
.map(|token| token.trim_start_matches(CONTINUATION_TOKEN_ORIGIN_PREFIX).to_string());
let mut origin_events_chunk: EventsChunk = origin_caller
.starknet_client
.get_events(
starknet_rs_core::types::EventFilter {
from_block: Some(ImportedBlockId::Number(from_origin)),
to_block: Some(ImportedBlockId::Number(to_origin)),
address: address.map(|address| address.into()),
keys,
},
origin_continuation_token,
chunk_size,
)
.await
.map_err(|e| {
ApiError::StarknetDevnetError(Error::UnexpectedInternalError {
msg: format!("Error in fetching origin events: {e:?}"),
})
})?
.into();
// If origin has no more chunks, set the token to default, which will signalize the
// switch to querying the local state on next request.
origin_events_chunk.continuation_token = origin_events_chunk
.continuation_token
.map_or(Some(DEFAULT_CONTINUATION_TOKEN.to_owned()), |token| {
Some(CONTINUATION_TOKEN_ORIGIN_PREFIX.to_owned() + &token)
});
Ok(origin_events_chunk)
}
/// starknet_getEvents
pub async fn get_events(&self, filter: EventFilter) -> StrictRpcResult {
let (origin_range, from_local_block_id, to_local_block_id) =
self.split_block_range(filter.from_block, filter.to_block).await?;
// Get events either from forking origin or locally
let events_chunk = if origin_range.is_some()
&& filter
.continuation_token
.clone()
.is_none_or(|token| token.starts_with(CONTINUATION_TOKEN_ORIGIN_PREFIX))
{
#[allow(clippy::unnecessary_unwrap)]
#[allow(clippy::expect_used)]
let (from_origin, to_origin) =
origin_range.expect("Continuation token implies there are more origin events");
self.fetch_origin_events_chunk(
from_origin,
to_origin,
filter.continuation_token,
filter.address,
filter.keys,
filter.chunk_size,
)
.await?
} else {
let pages_read_so_far = filter
.continuation_token
.unwrap_or(DEFAULT_CONTINUATION_TOKEN.to_string())
.parse::<u64>()
.map_err(|_| ApiError::InvalidContinuationToken)?;
let starknet = self.api.starknet.lock().await;
let (events, has_more_events) = starknet
.get_events(
from_local_block_id,
to_local_block_id,
filter.address,
filter.keys,
None,
pages_read_so_far * filter.chunk_size,
Some(filter.chunk_size),
)
.map_err(|e| match e {
Error::NoBlock => ApiError::BlockNotFound,
_ => e.into(),
})?;
EventsChunk {
events,
continuation_token: has_more_events.then(|| (pages_read_so_far + 1).to_string()),
}
};
Ok(StarknetResponse::Events(events_chunk).into())
}
/// starknet_getNonce
pub async fn get_nonce(
&self,
block_id: BlockId,
contract_address: ContractAddress,
) -> StrictRpcResult {
let nonce = self
.api
.starknet
.lock()
.await
.contract_nonce_at_block(&block_id, contract_address)
.map_err(|err| match err {
Error::NoBlock => ApiError::BlockNotFound,
Error::ContractNotFound => ApiError::ContractNotFound,
e @ Error::NoStateAtBlock { .. } => ApiError::NoStateAtBlock { msg: e.to_string() },
unknown_error => ApiError::StarknetDevnetError(unknown_error),
})?;
Ok(StarknetResponse::Felt(nonce).into())
}
/// starknet_simulateTransactions
pub async fn simulate_transactions(
&self,
block_id: BlockId,
transactions: Vec<BroadcastedTransaction>,
simulation_flags: Vec<SimulationFlag>,
) -> StrictRpcResult {
let mut starknet = self.api.starknet.lock().await;
match starknet.simulate_transactions(&block_id, &transactions, simulation_flags) {
Ok(result) => Ok(StarknetResponse::SimulateTransactions(result).into()),
Err(Error::ContractNotFound) => Err(ApiError::ContractNotFound),
Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
Err(e @ Error::NoStateAtBlock { .. }) => {
Err(ApiError::NoStateAtBlock { msg: e.to_string() })
}
Err(Error::ContractExecutionErrorInSimulation { failure_index, execution_error }) => {
Err(ApiError::TransactionExecutionError { failure_index, execution_error })
}
Err(e) => Err(ApiError::ContractError(ContractExecutionError::from(e.to_string()))),
}
}
/// starknet_traceTransaction
pub async fn get_trace_transaction(
&self,
transaction_hash: TransactionHash,
) -> StrictRpcResult {
let starknet = self.api.starknet.lock().await;
match starknet.get_transaction_trace_by_hash(transaction_hash) {
Ok(result) => Ok(StarknetResponse::TraceTransaction(result).into()),
Err(Error::NoTransaction) => Err(ApiError::TransactionNotFound),
Err(Error::UnsupportedTransactionType) => Err(ApiError::NoTraceAvailable),
Err(err) => Err(err.into()),
}
}
/// starknet_traceBlockTransactions
pub async fn get_trace_block_transactions(&self, block_id: BlockId) -> StrictRpcResult {
let starknet = self.api.starknet.lock().await;
match starknet.get_transaction_traces_from_block(&block_id) {
Ok(result) => Ok(StarknetResponse::BlockTransactionTraces(result).into()),
Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
Err(err) => Err(err.into()),
}
}
/// starknet_getMessagesStatus
pub async fn get_messages_status(
&self,
L1TransactionHashInput { transaction_hash }: L1TransactionHashInput,
) -> StrictRpcResult {
let starknet = self.api.starknet.lock().await;
match starknet.get_messages_status(transaction_hash) {
Some(statuses) => Ok(StarknetResponse::MessagesStatusByL1Hash(statuses).into()),
None => Err(ApiError::TransactionNotFound),
}
}
/// devnet_getPredeployedAccounts
pub async fn get_predeployed_accounts(
&self,
params: Option<PredeployedAccountsQuery>,
) -> StrictRpcResult {
let mut starknet = self.api.starknet.lock().await;
let mut predeployed_accounts: Vec<_> = starknet
.get_predeployed_accounts()
.into_iter()
.map(|acc| SerializableAccount {
initial_balance: acc.initial_balance.to_string(),
address: acc.account_address,
public_key: acc.keys.public_key,
private_key: acc.keys.private_key,
balance: None,
})
.collect();
// handle with_balance query string
if let Some(true) =
params.unwrap_or(PredeployedAccountsQuery { with_balance: Option::None }).with_balance
{
for account in predeployed_accounts.iter_mut() {
let eth = get_balance_unit(&mut starknet, account.address, FeeUnit::WEI)?;
let strk = get_balance_unit(&mut starknet, account.address, FeeUnit::FRI)?;
account.balance = Some(AccountBalancesResponse { eth, strk });
}
}
Ok(DevnetResponse::PredeployedAccounts(predeployed_accounts).into())
}
/// devnet_getAccountBalance
pub async fn get_account_balance(&self, params: BalanceQuery) -> StrictRpcResult {
let account_address = ContractAddress::new(params.address)
.map_err(|e| ApiError::InvalidAddress { msg: e.to_string() })?;
let unit = params.unit.unwrap_or(FeeUnit::FRI);
let erc20_address = get_erc20_fee_unit_address(&unit);
let mut starknet = self.api.starknet.lock().await;
let amount = get_balance(
&mut starknet,
account_address,
erc20_address,
params.block_id.unwrap_or(BlockId::Tag(BlockTag::Latest)),
)?;
Ok(DevnetResponse::AccountBalance(AccountBalanceResponse {
amount: amount.to_string(),
unit,
})
.into())
}
/// devnet_getConfig
pub async fn get_devnet_config(&self) -> StrictRpcResult {
Ok(DevnetResponse::DevnetConfig(DevnetConfig {
starknet_config: (*self.api.config).clone(),
server_config: (*self.api.server_config).clone(),
})
.into())
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/json_rpc_handler.rs | crates/starknet-devnet-server/src/api/json_rpc_handler.rs | use std::sync::Arc;
use axum::extract::ws::{Message, WebSocket};
use futures::stream::SplitSink;
use futures::{SinkExt, StreamExt};
use starknet_core::StarknetBlock;
use starknet_core::starknet::starknet_config::DumpOn;
use starknet_types::emitted_event::SubscriptionEmittedEvent;
use starknet_types::rpc::block::{BlockId, BlockTag, ReorgData};
use starknet_types::rpc::transactions::TransactionFinalityStatus;
use tokio::sync::Mutex;
use tracing::{info, trace};
use crate::api::models::{
AccountAddressInput, BlockAndClassHashInput, BlockAndContractAddressInput, BlockAndIndexInput,
BlockIdInput, BroadcastedDeclareTransactionEnumWrapper, BroadcastedDeclareTransactionInput,
BroadcastedDeployAccountTransactionEnumWrapper, BroadcastedDeployAccountTransactionInput,
BroadcastedInvokeTransactionEnumWrapper, BroadcastedInvokeTransactionInput, CallInput,
ClassHashInput, DevnetSpecRequest, EstimateFeeInput, EventsInput, GetStorageInput,
JsonRpcRequest, JsonRpcResponse, JsonRpcWsRequest, LoadPath, SimulateTransactionsInput,
StarknetSpecRequest, ToRpcResponseResult, TransactionHashInput, to_json_rpc_request,
};
use crate::api::origin_forwarder::OriginForwarder;
use crate::api::{Api, ApiError, error};
use crate::dump_util::dump_event;
use crate::restrictive_mode::is_json_rpc_method_restricted;
use crate::rpc_core;
use crate::rpc_core::error::{ErrorCode, RpcError};
use crate::rpc_core::request::RpcMethodCall;
use crate::rpc_core::response::{ResponseResult, RpcResponse};
use crate::rpc_handler::RpcHandler;
use crate::subscribe::{
NewTransactionNotification, NewTransactionReceiptNotification, NewTransactionStatus,
NotificationData, SocketId,
};
/// This object will be used as a shared state between HTTP calls.
/// Is similar to the HttpApiHandler but is with extended functionality and is used for JSON-RPC
/// methods
#[derive(Clone)]
pub struct JsonRpcHandler {
pub api: Api,
pub origin_caller: Option<OriginForwarder>,
}
#[async_trait::async_trait]
impl RpcHandler for JsonRpcHandler {
type Request = JsonRpcRequest;
async fn on_request(
&self,
request: Self::Request,
original_call: RpcMethodCall,
) -> ResponseResult {
info!(target: "rpc", "received method in on_request {}", request);
if !self.allows_method(&original_call.method) {
return ResponseResult::Error(RpcError::new(ErrorCode::MethodForbidden));
}
let is_request_forwardable = request.is_forwardable_to_origin(); // applicable if forking
let is_request_dumpable = request.is_dumpable();
// for later comparison and subscription notifications
let old_latest_block = if request.requires_notifying() {
Some(self.get_block_by_tag(BlockTag::Latest).await)
} else {
None
};
let old_pre_confirmed_block =
if request.requires_notifying() && self.api.config.uses_pre_confirmed_block() {
Some(self.get_block_by_tag(BlockTag::PreConfirmed).await)
} else {
None
};
let starknet_resp = self.execute(request).await;
// If locally we got an error and forking is set up, forward the request to the origin
if let (Err(err), Some(forwarder)) = (&starknet_resp, &self.origin_caller) {
if err.is_forwardable_to_origin() && is_request_forwardable {
// if a block or state is requested that was only added to origin after
// forking happened, it will be normally returned; we don't extra-handle this case
return forwarder.call(&original_call).await;
}
}
if starknet_resp.is_ok() && is_request_dumpable {
if let Err(e) = self.update_dump(&original_call).await {
return ResponseResult::Error(e);
}
}
if let Err(e) = self.broadcast_changes(old_latest_block, old_pre_confirmed_block).await {
return ResponseResult::Error(e.api_error_to_rpc_error());
}
starknet_resp.to_rpc_result()
}
async fn on_call(&self, call: RpcMethodCall) -> RpcResponse {
let id = call.id.clone();
trace!(target: "rpc", id = ?id, method = ?call.method, "received method call");
match to_json_rpc_request(&call) {
Ok(req) => {
let result = self.on_request(req, call).await;
RpcResponse::new(id, result)
}
Err(e) => RpcResponse::from_rpc_error(e, id),
}
}
async fn on_websocket(&self, socket: WebSocket) {
let (socket_writer, mut socket_reader) = socket.split();
let socket_writer = Arc::new(Mutex::new(socket_writer));
let socket_id = self.api.sockets.lock().await.insert(socket_writer.clone());
// listen to new messages coming through the socket
let mut socket_safely_closed = false;
while let Some(msg) = socket_reader.next().await {
match msg {
Ok(Message::Text(text)) => {
self.on_websocket_call(text.as_bytes(), socket_writer.clone(), socket_id).await;
}
Ok(Message::Binary(bytes)) => {
self.on_websocket_call(&bytes, socket_writer.clone(), socket_id).await;
}
Ok(Message::Close(_)) => {
socket_safely_closed = true;
break;
}
other => {
tracing::error!("Socket handler got an unexpected message: {other:?}")
}
}
}
self.api.sockets.lock().await.remove(&socket_id);
if socket_safely_closed {
tracing::info!("Websocket disconnected");
} else {
tracing::error!("Failed socket read");
}
}
}
impl JsonRpcHandler {
pub fn new(api: Api) -> JsonRpcHandler {
let origin_caller = if let (Some(url), Some(block_number)) =
(&api.config.fork_config.url, api.config.fork_config.block_number)
{
Some(OriginForwarder::new(url.clone(), block_number))
} else {
None
};
JsonRpcHandler { api, origin_caller }
}
/// The latest and pre_confirmed block are always defined, so to avoid having to deal with
/// Err/None in places where this method is called, it is defined to return an empty
/// accepted block, even though that case should never happen.
async fn get_block_by_tag(&self, tag: BlockTag) -> StarknetBlock {
let starknet = self.api.starknet.lock().await;
match starknet.get_block(&BlockId::Tag(tag)) {
Ok(block) => block.clone(),
_ => StarknetBlock::create_empty_accepted(),
}
}
async fn broadcast_pre_confirmed_tx_changes(
&self,
old_pre_confirmed_block: StarknetBlock,
) -> Result<(), error::ApiError> {
let new_pre_confirmed_block = self.get_block_by_tag(BlockTag::PreConfirmed).await;
let old_pre_confirmed_txs = old_pre_confirmed_block.get_transactions();
let new_pre_confirmed_txs = new_pre_confirmed_block.get_transactions();
if new_pre_confirmed_txs.len() > old_pre_confirmed_txs.len() {
#[allow(clippy::expect_used)]
let new_tx_hash = new_pre_confirmed_txs.last().expect("has at least one element");
let mut notifications = vec![];
let starknet = self.api.starknet.lock().await;
let status = starknet
.get_transaction_execution_and_finality_status(*new_tx_hash)
.map_err(error::ApiError::StarknetDevnetError)?;
notifications.push(NotificationData::TransactionStatus(NewTransactionStatus {
transaction_hash: *new_tx_hash,
status,
}));
let tx = starknet
.get_transaction_by_hash(*new_tx_hash)
.map_err(error::ApiError::StarknetDevnetError)?;
notifications.push(NotificationData::NewTransaction(NewTransactionNotification {
tx: tx.clone(),
finality_status: TransactionFinalityStatus::PreConfirmed,
}));
let receipt = starknet
.get_transaction_receipt_by_hash(new_tx_hash)
.map_err(error::ApiError::StarknetDevnetError)?;
notifications.push(NotificationData::NewTransactionReceipt(
NewTransactionReceiptNotification {
tx_receipt: receipt,
sender_address: tx.get_sender_address(),
},
));
let events = starknet.get_unlimited_events(
Some(BlockId::Tag(BlockTag::PreConfirmed)),
Some(BlockId::Tag(BlockTag::PreConfirmed)),
None,
None,
None, // pre-confirmed block only has pre-confirmed txs
)?;
drop(starknet); // Drop immediately after last use
for emitted_event in events.into_iter().filter(|e| &e.transaction_hash == new_tx_hash) {
notifications.push(NotificationData::Event(SubscriptionEmittedEvent {
emitted_event,
finality_status: TransactionFinalityStatus::PreConfirmed,
}));
}
self.api.sockets.lock().await.notify_subscribers(¬ifications).await;
}
Ok(())
}
async fn broadcast_latest_changes(
&self,
new_latest_block: StarknetBlock,
) -> Result<(), error::ApiError> {
let block_header = (&new_latest_block).into();
let mut notifications = vec![NotificationData::NewHeads(block_header)];
let starknet = self.api.starknet.lock().await;
let finality_status = TransactionFinalityStatus::AcceptedOnL2;
let latest_txs = new_latest_block.get_transactions();
for tx_hash in latest_txs {
let tx = starknet
.get_transaction_by_hash(*tx_hash)
.map_err(error::ApiError::StarknetDevnetError)?;
notifications.push(NotificationData::NewTransaction(NewTransactionNotification {
tx: tx.clone(),
finality_status,
}));
let status = starknet
.get_transaction_execution_and_finality_status(*tx_hash)
.map_err(error::ApiError::StarknetDevnetError)?;
notifications.push(NotificationData::TransactionStatus(NewTransactionStatus {
transaction_hash: *tx_hash,
status,
}));
let tx_receipt = starknet
.get_transaction_receipt_by_hash(tx_hash)
.map_err(error::ApiError::StarknetDevnetError)?;
notifications.push(NotificationData::NewTransactionReceipt(
NewTransactionReceiptNotification {
tx_receipt,
sender_address: tx.get_sender_address(),
},
));
}
let events = starknet.get_unlimited_events(
Some(BlockId::Tag(BlockTag::Latest)),
Some(BlockId::Tag(BlockTag::Latest)),
None,
None,
None, // latest block only has txs accepted on L2
)?;
drop(starknet); // Drop immediately after last use
for emitted_event in events {
notifications.push(NotificationData::Event(SubscriptionEmittedEvent {
emitted_event,
finality_status,
}));
}
self.api.sockets.lock().await.notify_subscribers(¬ifications).await;
Ok(())
}
/// Notify subscribers of what they are subscribed to.
async fn broadcast_changes(
&self,
old_latest_block: Option<StarknetBlock>,
old_pre_confirmed_block: Option<StarknetBlock>,
) -> Result<(), error::ApiError> {
let Some(old_latest_block) = old_latest_block else {
return Ok(());
};
if let Some(old_pre_confirmed_block) = old_pre_confirmed_block {
self.broadcast_pre_confirmed_tx_changes(old_pre_confirmed_block).await?;
}
let new_latest_block = self.get_block_by_tag(BlockTag::Latest).await;
match new_latest_block.block_number().cmp(&old_latest_block.block_number()) {
std::cmp::Ordering::Less => {
self.broadcast_reorg(old_latest_block, new_latest_block).await?
}
std::cmp::Ordering::Equal => { /* no changes required */ }
std::cmp::Ordering::Greater => self.broadcast_latest_changes(new_latest_block).await?,
}
Ok(())
}
async fn broadcast_reorg(
&self,
old_latest_block: StarknetBlock,
new_latest_block: StarknetBlock,
) -> Result<(), ApiError> {
let last_aborted_block_hash =
*self.api.starknet.lock().await.last_aborted_block_hash().ok_or(
ApiError::StarknetDevnetError(
starknet_core::error::Error::UnexpectedInternalError {
msg: "Aborted block hash should be defined.".into(),
},
),
)?;
let notification = NotificationData::Reorg(ReorgData {
starting_block_hash: last_aborted_block_hash,
starting_block_number: new_latest_block.block_number().unchecked_next(),
ending_block_hash: old_latest_block.block_hash(),
ending_block_number: old_latest_block.block_number(),
});
self.api.sockets.lock().await.notify_subscribers(&[notification]).await;
Ok(())
}
/// Matches the request to the corresponding enum variant and executes the request.
async fn execute(&self, req: JsonRpcRequest) -> Result<JsonRpcResponse, error::ApiError> {
trace!(target: "JsonRpcHandler::execute", "executing request");
match req {
JsonRpcRequest::StarknetSpecRequest(req) => self.execute_starknet_spec(req).await,
JsonRpcRequest::DevnetSpecRequest(req) => self.execute_devnet_spec(req).await,
}
}
async fn execute_starknet_spec(
&self,
req: StarknetSpecRequest,
) -> Result<JsonRpcResponse, error::ApiError> {
match req {
StarknetSpecRequest::SpecVersion => self.spec_version(),
StarknetSpecRequest::BlockWithTransactionHashes(block) => {
self.get_block_with_tx_hashes(block.block_id).await
}
StarknetSpecRequest::BlockWithFullTransactions(block) => {
self.get_block_with_txs(block.block_id).await
}
StarknetSpecRequest::BlockWithReceipts(block) => {
self.get_block_with_receipts(block.block_id).await
}
StarknetSpecRequest::StateUpdate(block) => self.get_state_update(block.block_id).await,
StarknetSpecRequest::StorageAt(GetStorageInput { contract_address, key, block_id }) => {
self.get_storage_at(contract_address, key, block_id).await
}
StarknetSpecRequest::TransactionStatusByHash(TransactionHashInput {
transaction_hash,
}) => self.get_transaction_status_by_hash(transaction_hash).await,
StarknetSpecRequest::TransactionByHash(TransactionHashInput { transaction_hash }) => {
self.get_transaction_by_hash(transaction_hash).await
}
StarknetSpecRequest::TransactionByBlockAndIndex(BlockAndIndexInput {
block_id,
index,
}) => self.get_transaction_by_block_id_and_index(block_id, index).await,
StarknetSpecRequest::TransactionReceiptByTransactionHash(TransactionHashInput {
transaction_hash,
}) => self.get_transaction_receipt_by_hash(transaction_hash).await,
StarknetSpecRequest::ClassByHash(BlockAndClassHashInput { block_id, class_hash }) => {
self.get_class(block_id, class_hash).await
}
StarknetSpecRequest::CompiledCasmByClassHash(ClassHashInput { class_hash }) => {
self.get_compiled_casm(class_hash).await
}
StarknetSpecRequest::ClassHashAtContractAddress(BlockAndContractAddressInput {
block_id,
contract_address,
}) => self.get_class_hash_at(block_id, contract_address).await,
StarknetSpecRequest::ClassAtContractAddress(BlockAndContractAddressInput {
block_id,
contract_address,
}) => self.get_class_at(block_id, contract_address).await,
StarknetSpecRequest::BlockTransactionCount(block) => {
self.get_block_txs_count(block.block_id).await
}
StarknetSpecRequest::Call(CallInput { request, block_id }) => {
self.call(block_id, request).await
}
StarknetSpecRequest::EstimateFee(EstimateFeeInput {
request,
block_id,
simulation_flags,
}) => self.estimate_fee(block_id, request, simulation_flags).await,
StarknetSpecRequest::BlockNumber => self.block_number().await,
StarknetSpecRequest::BlockHashAndNumber => self.block_hash_and_number().await,
StarknetSpecRequest::ChainId => self.chain_id().await,
StarknetSpecRequest::Syncing => self.syncing().await,
StarknetSpecRequest::Events(EventsInput { filter }) => self.get_events(filter).await,
StarknetSpecRequest::ContractNonce(BlockAndContractAddressInput {
block_id,
contract_address,
}) => self.get_nonce(block_id, contract_address).await,
StarknetSpecRequest::AddDeclareTransaction(BroadcastedDeclareTransactionInput {
declare_transaction,
}) => {
let BroadcastedDeclareTransactionEnumWrapper::Declare(broadcasted_transaction) =
declare_transaction;
self.add_declare_transaction(broadcasted_transaction).await
}
StarknetSpecRequest::AddDeployAccountTransaction(
BroadcastedDeployAccountTransactionInput { deploy_account_transaction },
) => {
let BroadcastedDeployAccountTransactionEnumWrapper::DeployAccount(
broadcasted_transaction,
) = deploy_account_transaction;
self.add_deploy_account_transaction(broadcasted_transaction).await
}
StarknetSpecRequest::AddInvokeTransaction(BroadcastedInvokeTransactionInput {
invoke_transaction,
}) => {
let BroadcastedInvokeTransactionEnumWrapper::Invoke(broadcasted_transaction) =
invoke_transaction;
self.add_invoke_transaction(broadcasted_transaction).await
}
StarknetSpecRequest::EstimateMessageFee(request) => {
self.estimate_message_fee(request.get_block_id(), request.get_raw_message().clone())
.await
}
StarknetSpecRequest::SimulateTransactions(SimulateTransactionsInput {
block_id,
transactions,
simulation_flags,
}) => self.simulate_transactions(block_id, transactions, simulation_flags).await,
StarknetSpecRequest::TraceTransaction(TransactionHashInput { transaction_hash }) => {
self.get_trace_transaction(transaction_hash).await
}
StarknetSpecRequest::BlockTransactionTraces(BlockIdInput { block_id }) => {
self.get_trace_block_transactions(block_id).await
}
StarknetSpecRequest::MessagesStatusByL1Hash(data) => {
self.get_messages_status(data).await
}
StarknetSpecRequest::StorageProof(data) => self.get_storage_proof(data).await,
}
}
async fn execute_devnet_spec(
&self,
req: DevnetSpecRequest,
) -> Result<JsonRpcResponse, error::ApiError> {
match req {
DevnetSpecRequest::ImpersonateAccount(AccountAddressInput { account_address }) => {
self.impersonate_account(account_address).await
}
DevnetSpecRequest::StopImpersonateAccount(AccountAddressInput { account_address }) => {
self.stop_impersonating_account(account_address).await
}
DevnetSpecRequest::AutoImpersonate => self.set_auto_impersonate(true).await,
DevnetSpecRequest::StopAutoImpersonate => self.set_auto_impersonate(false).await,
DevnetSpecRequest::Dump(path) => self.dump(path).await,
DevnetSpecRequest::Load(LoadPath { path }) => self.load(path).await,
DevnetSpecRequest::PostmanLoadL1MessagingContract(data) => {
self.postman_load(data).await
}
DevnetSpecRequest::PostmanFlush(data) => self.postman_flush(data).await,
DevnetSpecRequest::PostmanSendMessageToL2(message) => {
self.postman_send_message_to_l2(message).await
}
DevnetSpecRequest::PostmanConsumeMessageFromL2(message) => {
self.postman_consume_message_from_l2(message).await
}
DevnetSpecRequest::CreateBlock => self.create_block().await,
DevnetSpecRequest::AbortBlocks(data) => self.abort_blocks(data).await,
DevnetSpecRequest::AcceptOnL1(data) => self.accept_on_l1(data).await,
DevnetSpecRequest::SetGasPrice(data) => self.set_gas_price(data).await,
DevnetSpecRequest::Restart(data) => self.restart(data).await,
DevnetSpecRequest::SetTime(data) => self.set_time(data).await,
DevnetSpecRequest::IncreaseTime(data) => self.increase_time(data).await,
DevnetSpecRequest::PredeployedAccounts(data) => {
self.get_predeployed_accounts(data).await
}
DevnetSpecRequest::AccountBalance(data) => self.get_account_balance(data).await,
DevnetSpecRequest::Mint(data) => self.mint(data).await,
DevnetSpecRequest::DevnetConfig => self.get_devnet_config().await,
}
}
/// Takes `bytes` to be an encoded RPC call, executes it, and sends the response back via `ws`.
async fn on_websocket_call(
&self,
bytes: &[u8],
ws: Arc<Mutex<SplitSink<WebSocket, Message>>>,
socket_id: SocketId,
) {
let error_serialized = match serde_json::from_slice(bytes) {
Ok(rpc_call) => match self.on_websocket_rpc_call(&rpc_call, socket_id).await {
Ok(_) => return,
Err(e) => serde_json::to_string(&RpcResponse::from_rpc_error(e, rpc_call.id))
.unwrap_or_default(),
},
Err(e) => serde_json::to_string(&RpcResponse::from_rpc_error(
RpcError::parse_error(e.to_string()),
rpc_core::request::Id::Null,
))
.unwrap_or_default(),
};
if let Err(e) = ws.lock().await.send(Message::Text(error_serialized.into())).await {
tracing::error!("Error sending websocket message: {e}");
}
}
fn allows_method(&self, method: &str) -> bool {
if let Some(restricted_methods) = &self.api.server_config.restricted_methods {
if is_json_rpc_method_restricted(method, restricted_methods) {
return false;
}
}
true
}
/// Since some subscriptions might need to send multiple messages, sending messages other than
/// errors is left to individual RPC method handlers and this method returns an empty successful
/// Result. A one-time request also returns an empty successful result, but actually sends the
/// message.
async fn on_websocket_rpc_call(
&self,
call: &RpcMethodCall,
socket_id: SocketId,
) -> Result<(), RpcError> {
trace!(target: "rpc", id = ?call.id, method = ?call.method, "received websocket call");
let req: JsonRpcWsRequest = to_json_rpc_request(call)?;
match req {
JsonRpcWsRequest::OneTimeRequest(req) => {
let resp_result = self.on_request(*req, call.clone()).await;
let mut sockets = self.api.sockets.lock().await;
let socket_context =
sockets.get_mut(&socket_id).map_err(|e| e.api_error_to_rpc_error())?;
match resp_result {
ResponseResult::Success(result_value) => {
socket_context.send_rpc_response(result_value, call.id.clone()).await;
Ok(())
}
ResponseResult::Error(rpc_error) => Err(rpc_error),
}
}
JsonRpcWsRequest::SubscriptionRequest(req) => self
.execute_ws_subscription(req, call.id.clone(), socket_id)
.await
.map_err(|e| e.api_error_to_rpc_error()),
}
}
async fn update_dump(&self, event: &RpcMethodCall) -> Result<(), RpcError> {
match self.api.config.dump_on {
Some(DumpOn::Block) => {
let dump_path = self
.api
.config
.dump_path
.as_deref()
.ok_or(RpcError::internal_error_with("Undefined dump_path"))?;
dump_event(event, dump_path).map_err(|e| {
let msg = format!("Failed dumping of {}: {e}", event.method);
RpcError::internal_error_with(msg)
})?;
}
Some(DumpOn::Request | DumpOn::Exit) => {
self.api.dumpable_events.lock().await.push(event.clone())
}
None => (),
}
Ok(())
}
pub async fn re_execute(&self, events: &[RpcMethodCall]) -> Result<(), RpcError> {
for event in events {
if let ResponseResult::Error(e) = self.on_call(event.clone()).await.result {
return Err(e);
}
}
Ok(())
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/error.rs | crates/starknet-devnet-server/src/api/error.rs | use serde_json::json;
use starknet_core::error::{ContractExecutionError, TransactionValidationError};
use starknet_rs_core::types::Felt;
use starknet_types;
use starknet_types::felt::Nonce;
use starknet_types::starknet_api::core::ContractAddress;
use thiserror::Error;
use tracing::error;
use crate::api::models::{JsonRpcResponse, WILDCARD_RPC_ERROR_CODE};
use crate::rpc_core::error::RpcError;
#[allow(unused)]
#[derive(Error, Debug)]
pub enum ApiError {
#[error(transparent)]
StarknetDevnetError(#[from] starknet_core::error::Error),
#[error("Types error")]
TypesError(#[from] starknet_types::error::Error),
#[error("Rpc error {0:?}")]
RpcError(RpcError),
#[error("Block not found")]
BlockNotFound,
#[error("Contract not found")]
ContractNotFound,
#[error("Transaction hash not found")]
TransactionNotFound,
#[error("Invalid transaction index in a block")]
InvalidTransactionIndexInBlock,
#[error("Class hash not found")]
ClassHashNotFound,
#[error("Contract error")]
ContractError(ContractExecutionError),
#[error("Transaction execution error")]
TransactionExecutionError { failure_index: usize, execution_error: ContractExecutionError },
#[error("There are no blocks")]
NoBlocks,
#[error("Requested page size is too big")]
RequestPageSizeTooBig,
#[error("The supplied continuation token is invalid or unknown")]
InvalidContinuationToken,
#[error("Too many keys provided in a filter")]
TooManyKeysInFilter,
#[error("Class already declared")]
ClassAlreadyDeclared,
#[error("Invalid contract class")]
InvalidContractClass,
#[error("{msg}")]
UnsupportedAction { msg: String },
#[error("Invalid transaction nonce")]
InvalidTransactionNonce {
address: ContractAddress,
account_nonce: Nonce,
incoming_tx_nonce: Nonce,
},
#[error("The transaction's resources don't cover validation or the minimal transaction fee")]
InsufficientResourcesForValidate,
#[error(
"Account balance is smaller than the transaction's maximal fee (calculated as the sum of \
each resource's limit x max price)"
)]
InsufficientAccountBalance,
#[error("Account validation failed")]
ValidationFailure { reason: String },
#[error("No trace available for transaction")]
NoTraceAvailable,
#[error("{msg}")]
NoStateAtBlock { msg: String },
#[error("the compiled class hash did not match the one supplied in the transaction")]
CompiledClassHashMismatch,
#[error("Requested entrypoint does not exist in the contract")]
EntrypointNotFound,
#[error("Cannot go back more than 1024 blocks")]
TooManyBlocksBack,
#[error("Invalid subscription id")]
InvalidSubscriptionId,
#[error("Devnet doesn't support storage proofs")] // slightly modified spec message
StorageProofNotSupported,
#[error("Contract class size is too large")]
ContractClassSizeIsTooLarge,
#[error("Minting reverted")]
MintingReverted { tx_hash: Felt, revert_reason: Option<String> },
#[error("The dump operation failed: {msg}")]
DumpError { msg: String },
#[error("Messaging error: {msg}")]
MessagingError { msg: String },
#[error("Invalid address: {msg}")]
InvalidAddress { msg: String },
}
impl ApiError {
pub fn api_error_to_rpc_error(self) -> RpcError {
let error_message = self.to_string();
match self {
ApiError::RpcError(rpc_error) => rpc_error,
ApiError::BlockNotFound => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(24),
message: error_message.into(),
data: None,
},
ApiError::ContractNotFound => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(20),
message: error_message.into(),
data: None,
},
ApiError::TransactionNotFound => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(29),
message: error_message.into(),
data: None,
},
ApiError::InvalidTransactionIndexInBlock => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(27),
message: error_message.into(),
data: None,
},
ApiError::ClassHashNotFound => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(28),
message: error_message.into(),
data: None,
},
ApiError::ContractError(contract_execution_error) => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(40),
message: error_message.into(),
data: Some(json!({
"revert_error": contract_execution_error
})),
},
ApiError::TransactionExecutionError { execution_error, failure_index } => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(41),
message: error_message.into(),
data: Some(serde_json::json!({
"transaction_index": failure_index,
"execution_error": execution_error,
})),
},
ApiError::NoBlocks => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(32),
message: error_message.into(),
data: None,
},
ApiError::RequestPageSizeTooBig => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(31),
message: error_message.into(),
data: None,
},
ApiError::InvalidContinuationToken => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(33),
message: error_message.into(),
data: None,
},
ApiError::TooManyKeysInFilter => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(34),
message: error_message.into(),
data: None,
},
ApiError::ClassAlreadyDeclared => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(51),
message: error_message.into(),
data: None,
},
ApiError::InvalidContractClass => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(50),
message: error_message.into(),
data: None,
},
ApiError::TypesError(_) => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(WILDCARD_RPC_ERROR_CODE),
message: error_message.into(),
data: None,
},
ApiError::UnsupportedAction { msg } => RpcError {
code: crate::rpc_core::error::ErrorCode::InvalidRequest,
message: msg.into(),
data: None,
},
ApiError::InsufficientResourcesForValidate => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(53),
message: error_message.into(),
data: None,
},
ApiError::InvalidTransactionNonce { address, account_nonce, incoming_tx_nonce } => {
RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(52),
message: error_message.into(),
data: Some(json!(format!(
"Invalid transaction nonce of contract at address {address}. Account \
nonce: {account_nonce}; got: {incoming_tx_nonce}."
))),
}
}
ApiError::InsufficientAccountBalance => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(54),
message: error_message.into(),
data: None,
},
ApiError::ValidationFailure { reason } => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(55),
message: error_message.into(),
data: Some(serde_json::Value::String(reason)),
},
ApiError::CompiledClassHashMismatch => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(60),
message: error_message.into(),
data: None,
},
ApiError::StarknetDevnetError(
starknet_core::error::Error::TransactionValidationError(validation_error),
) => {
let api_err = match validation_error {
TransactionValidationError::InsufficientResourcesForValidate => {
ApiError::InsufficientResourcesForValidate
}
TransactionValidationError::InvalidTransactionNonce {
address,
account_nonce,
incoming_tx_nonce,
} => ApiError::InvalidTransactionNonce {
address: address.into(),
account_nonce: *account_nonce,
incoming_tx_nonce: *incoming_tx_nonce,
},
TransactionValidationError::InsufficientAccountBalance => {
ApiError::InsufficientAccountBalance
}
TransactionValidationError::ValidationFailure { reason } => {
ApiError::ValidationFailure { reason }
}
};
api_err.api_error_to_rpc_error()
}
ApiError::StarknetDevnetError(error) => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(WILDCARD_RPC_ERROR_CODE),
message: anyhow::format_err!(error).root_cause().to_string().into(),
data: None,
},
ApiError::NoTraceAvailable => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(10),
message: error_message.into(),
data: None,
},
ApiError::NoStateAtBlock { .. } => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(WILDCARD_RPC_ERROR_CODE),
message: error_message.into(),
data: None,
},
ApiError::EntrypointNotFound => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(21),
message: error_message.into(),
data: None,
},
ApiError::TooManyBlocksBack => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(68),
message: error_message.into(),
data: None,
},
ApiError::InvalidSubscriptionId => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(66),
message: error_message.into(),
data: None,
},
ApiError::StorageProofNotSupported => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(42),
message: error_message.into(),
data: None,
},
ApiError::ContractClassSizeIsTooLarge => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(57),
message: error_message.into(),
data: None,
},
ApiError::MintingReverted { tx_hash, revert_reason: reason } => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(WILDCARD_RPC_ERROR_CODE),
message: error_message.into(),
data: Some(serde_json::json!({ "tx_hash": tx_hash, "revert_reason": reason })),
},
ApiError::DumpError { msg } => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(WILDCARD_RPC_ERROR_CODE),
message: msg.into(),
data: None,
},
ApiError::MessagingError { msg } => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(WILDCARD_RPC_ERROR_CODE),
message: msg.into(),
data: None,
},
ApiError::InvalidAddress { msg } => RpcError {
code: crate::rpc_core::error::ErrorCode::ServerError(WILDCARD_RPC_ERROR_CODE),
message: msg.into(),
data: None,
},
}
}
pub(crate) fn is_forwardable_to_origin(&self) -> bool {
#[warn(clippy::wildcard_enum_match_arm)]
match self {
Self::BlockNotFound
| Self::TransactionNotFound
| Self::NoStateAtBlock { .. }
| Self::ClassHashNotFound => true,
Self::StarknetDevnetError(_)
| Self::NoTraceAvailable
| Self::TypesError(_)
| Self::RpcError(_)
| Self::ContractNotFound // Doesn't require forwarding, handled at state reader level
| Self::InvalidTransactionIndexInBlock
| Self::ContractError { .. }
| Self::NoBlocks
| Self::RequestPageSizeTooBig
| Self::InvalidContinuationToken
| Self::TooManyKeysInFilter
| Self::ClassAlreadyDeclared
| Self::InvalidContractClass
| Self::UnsupportedAction { .. }
| Self::InvalidTransactionNonce { .. }
| Self::InsufficientAccountBalance
| Self::ValidationFailure { .. }
| Self::EntrypointNotFound
| Self::TransactionExecutionError { .. }
| Self::TooManyBlocksBack
| Self::InvalidSubscriptionId
| Self::InsufficientResourcesForValidate
| Self::StorageProofNotSupported
| Self::ContractClassSizeIsTooLarge
| Self::MintingReverted { .. }
| Self::CompiledClassHashMismatch
| Self::DumpError { .. }
| Self::MessagingError { .. }
| Self::InvalidAddress { .. } => false,
}
}
}
pub type StrictRpcResult = Result<JsonRpcResponse, ApiError>;
#[cfg(test)]
mod tests {
use serde_json::json;
use starknet_core::error::ContractExecutionError;
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::starknet_api::core::Nonce;
use super::StrictRpcResult;
use crate::api::error::ApiError;
use crate::api::models::ToRpcResponseResult;
use crate::rpc_core::error::{ErrorCode, RpcError};
#[test]
fn contract_not_found_error() {
error_expected_code_and_message(ApiError::ContractNotFound, 20, "Contract not found");
}
#[test]
fn block_not_found_error() {
error_expected_code_and_message(ApiError::BlockNotFound, 24, "Block not found");
}
#[test]
fn transaction_not_found_error() {
error_expected_code_and_message(
ApiError::TransactionNotFound,
29,
"Transaction hash not found",
);
}
#[test]
fn invalid_transaction_index_error() {
error_expected_code_and_message(
ApiError::InvalidTransactionIndexInBlock,
27,
"Invalid transaction index in a block",
);
}
#[test]
fn class_hash_not_found_error() {
error_expected_code_and_message(ApiError::ClassHashNotFound, 28, "Class hash not found");
}
#[test]
fn page_size_too_big_error() {
error_expected_code_and_message(
ApiError::RequestPageSizeTooBig,
31,
"Requested page size is too big",
);
}
#[test]
fn no_blocks_error() {
error_expected_code_and_message(ApiError::NoBlocks, 32, "There are no blocks");
}
#[test]
fn invalid_continuation_token_error() {
error_expected_code_and_message(
ApiError::InvalidContinuationToken,
33,
"The supplied continuation token is invalid or unknown",
);
}
#[test]
fn too_many_keys_in_filter_error() {
error_expected_code_and_message(
ApiError::TooManyKeysInFilter,
34,
"Too many keys provided in a filter",
);
}
#[test]
fn contract_error() {
let api_error =
ApiError::ContractError(ContractExecutionError::Message("some_reason".to_string()));
error_expected_code_and_message(api_error, 40, "Contract error");
// check contract error data property
let error =
ApiError::ContractError(ContractExecutionError::Message("some_reason".to_string()))
.api_error_to_rpc_error();
let error_data = error.data.unwrap();
assert_eq!(error_data["revert_error"].as_str().unwrap(), "some_reason");
}
#[test]
fn transaction_execution_error() {
error_expected_code_and_message(
ApiError::TransactionExecutionError {
failure_index: 0,
execution_error: ContractExecutionError::Message("anything".to_string()),
},
41,
"Transaction execution error",
);
error_expected_code_and_data(
ApiError::TransactionExecutionError {
failure_index: 1,
execution_error: ContractExecutionError::Message("anything".to_string()),
},
41,
&serde_json::json!({ "transaction_index": 1, "execution_error": "anything" }),
);
}
#[test]
fn invalid_transaction_nonce_error() {
let devnet_error =
ApiError::StarknetDevnetError(starknet_core::error::Error::TransactionValidationError(
starknet_core::error::TransactionValidationError::InvalidTransactionNonce {
address: ContractAddress::zero(),
account_nonce: Nonce(Felt::ONE),
incoming_tx_nonce: Nonce(Felt::TWO),
},
));
assert_eq!(
devnet_error.api_error_to_rpc_error(),
RpcError {
code: ErrorCode::ServerError(52),
message: "Invalid transaction nonce".into(),
data: Some(json!(
"Invalid transaction nonce of contract at address \
0x0000000000000000000000000000000000000000000000000000000000000000. Account \
nonce: 1; got: 2."
))
}
);
}
#[test]
fn insufficient_resources_error() {
let devnet_error =
ApiError::StarknetDevnetError(starknet_core::error::Error::TransactionValidationError(
starknet_core::error::TransactionValidationError::InsufficientResourcesForValidate,
));
assert_eq!(
devnet_error.api_error_to_rpc_error(),
ApiError::InsufficientResourcesForValidate.api_error_to_rpc_error()
);
error_expected_code_and_message(
ApiError::InsufficientResourcesForValidate,
53,
"The transaction's resources don't cover validation or the minimal transaction fee",
);
}
#[test]
fn insufficient_account_balance_error() {
let devnet_error =
ApiError::StarknetDevnetError(starknet_core::error::Error::TransactionValidationError(
starknet_core::error::TransactionValidationError::InsufficientAccountBalance,
));
assert_eq!(
devnet_error.api_error_to_rpc_error(),
ApiError::InsufficientAccountBalance.api_error_to_rpc_error()
);
error_expected_code_and_message(
ApiError::InsufficientAccountBalance,
54,
"Account balance is smaller than the transaction's maximal fee (calculated as the sum \
of each resource's limit x max price)",
);
}
#[test]
fn account_validation_error() {
let reason = String::from("some reason");
let devnet_error =
ApiError::StarknetDevnetError(starknet_core::error::Error::TransactionValidationError(
starknet_core::error::TransactionValidationError::ValidationFailure {
reason: reason.clone(),
},
));
assert_eq!(
devnet_error.api_error_to_rpc_error(),
ApiError::ValidationFailure { reason: reason.clone() }.api_error_to_rpc_error()
);
error_expected_code_and_message(
ApiError::ValidationFailure { reason: reason.clone() },
55,
"Account validation failed",
);
error_expected_code_and_data(
ApiError::ValidationFailure { reason: reason.clone() },
55,
&serde_json::json!(reason),
);
}
#[test]
fn minting_reverted_error() {
let revert_reason = String::from("some kind of reason");
let devnet_error = ApiError::MintingReverted {
tx_hash: Felt::ONE,
revert_reason: Some(revert_reason.clone()),
};
error_expected_code_and_data(
devnet_error,
-1,
&serde_json::json!({
"tx_hash": "0x1",
"revert_reason": revert_reason,
}),
);
}
fn error_expected_code_and_message(err: ApiError, expected_code: i64, expected_message: &str) {
let error_result = StrictRpcResult::Err(err).to_rpc_result();
match error_result {
crate::rpc_core::response::ResponseResult::Success(_) => panic!("Expected error"),
crate::rpc_core::response::ResponseResult::Error(err) => {
assert_eq!(err.message, expected_message);
assert_eq!(err.code, crate::rpc_core::error::ErrorCode::ServerError(expected_code))
}
}
}
fn error_expected_code_and_data(
err: ApiError,
expected_code: i64,
expected_data: &serde_json::Value,
) {
let error_result = StrictRpcResult::Err(err).to_rpc_result();
match error_result {
crate::rpc_core::response::ResponseResult::Success(_) => panic!("Expected error"),
crate::rpc_core::response::ResponseResult::Error(err) => {
assert_eq!(&err.data.unwrap(), expected_data);
assert_eq!(err.code, crate::rpc_core::error::ErrorCode::ServerError(expected_code))
}
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/account_helpers.rs | crates/starknet-devnet-server/src/api/account_helpers.rs | use serde::Deserialize;
use starknet_core::constants::{ETH_ERC20_CONTRACT_ADDRESS, STRK_ERC20_CONTRACT_ADDRESS};
use starknet_core::starknet::Starknet;
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::felt::join_felts;
use starknet_types::num_bigint::BigUint;
use starknet_types::rpc::block::{BlockId, BlockTag};
use starknet_types::rpc::transaction_receipt::FeeUnit;
use crate::api::error::ApiError;
use crate::api::models::AccountBalanceResponse;
#[derive(Deserialize, Debug)]
#[serde(deny_unknown_fields)]
pub struct BalanceQuery {
pub address: Felt,
pub unit: Option<FeeUnit>,
pub block_id: Option<BlockId>,
}
#[derive(Deserialize, Debug)]
#[serde(deny_unknown_fields)]
pub struct PredeployedAccountsQuery {
pub with_balance: Option<bool>,
}
pub fn get_balance(
starknet: &mut Starknet,
address: ContractAddress,
erc20_address: ContractAddress,
block_id: BlockId,
) -> Result<BigUint, ApiError> {
let balance_selector =
starknet_rs_core::utils::get_selector_from_name("balanceOf").map_err(|err| {
starknet_core::error::Error::UnexpectedInternalError { msg: err.to_string() }
})?;
let new_balance_raw = starknet.call(
&block_id,
erc20_address.into(),
balance_selector,
vec![Felt::from(address)], // calldata = the address being queried
)?;
match new_balance_raw.as_slice() {
// format balance for output - initially it is a 2-member vector (low, high)
[new_balance_low, new_balance_high] => Ok(join_felts(new_balance_high, new_balance_low)),
_ => {
let msg = format!(
"Fee token contract expected to return 2 values; got: {new_balance_raw:?}",
);
Err(ApiError::StarknetDevnetError(
starknet_core::error::Error::UnexpectedInternalError { msg },
))
}
}
}
pub fn get_erc20_fee_unit_address(unit: &FeeUnit) -> ContractAddress {
match unit {
FeeUnit::WEI => ContractAddress::new_unchecked(ETH_ERC20_CONTRACT_ADDRESS),
FeeUnit::FRI => ContractAddress::new_unchecked(STRK_ERC20_CONTRACT_ADDRESS),
}
}
pub fn get_balance_unit(
starknet: &mut Starknet,
address: ContractAddress,
unit: FeeUnit,
) -> Result<AccountBalanceResponse, ApiError> {
let erc20_address = get_erc20_fee_unit_address(&unit);
let amount =
get_balance(starknet, address, erc20_address, BlockId::Tag(BlockTag::PreConfirmed))?;
Ok(AccountBalanceResponse { amount: amount.to_string(), unit })
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_new_unchecked_vs_new_for_fee_addresses() {
// For ETH address
let contract_address_checked = ContractAddress::new(ETH_ERC20_CONTRACT_ADDRESS).unwrap();
let contract_address_unchecked = ContractAddress::new_unchecked(ETH_ERC20_CONTRACT_ADDRESS);
assert_eq!(
contract_address_checked, contract_address_unchecked,
"ContractAddress::new and ContractAddress::new_unchecked should produce the same \
result for valid ETH address"
);
// For STRK address
let contract_address_checked = ContractAddress::new(STRK_ERC20_CONTRACT_ADDRESS).unwrap();
let contract_address_unchecked =
ContractAddress::new_unchecked(STRK_ERC20_CONTRACT_ADDRESS);
assert_eq!(
contract_address_checked, contract_address_unchecked,
"ContractAddress::new and ContractAddress::new_unchecked should produce the same \
result for valid STRK address"
);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/origin_forwarder.rs | crates/starknet-devnet-server/src/api/origin_forwarder.rs | use std::sync::Arc;
use serde_json::json;
use starknet_rs_core::types::{
BlockId as ImportedBlockId, BlockTag as ImportedBlockTag, BlockWithTxHashes,
MaybePreConfirmedBlockWithTxHashes,
};
use starknet_rs_providers::jsonrpc::HttpTransport;
use starknet_rs_providers::{JsonRpcClient, Provider};
use starknet_types::rpc::block::{BlockId, BlockTag};
use super::error::ApiError;
use crate::rpc_core::error::RpcError;
use crate::rpc_core::request::RpcMethodCall;
use crate::rpc_core::response::{ResponseResult, RpcResponse};
/// Used for forwarding requests to origin in case of:
/// - BlockNotFound
/// - TransactionNotFound
/// - NoStateAtBlock
/// - ClassHashNotFound
///
/// Basic contract-wise interaction is handled by `BlockingOriginReader`
#[derive(Clone)]
pub struct OriginForwarder {
reqwest_client: reqwest::Client,
url: Arc<String>,
block_number: u64,
pub(crate) starknet_client: JsonRpcClient<HttpTransport>,
}
impl OriginForwarder {
pub fn new(url: url::Url, block_number: u64) -> Self {
Self {
reqwest_client: reqwest::Client::new(),
url: Arc::new(url.to_string()),
block_number,
starknet_client: JsonRpcClient::new(HttpTransport::new(url)),
}
}
pub fn fork_block_number(&self) -> u64 {
self.block_number
}
/// In case block tag "pre_confirmed" or "latest" is a part of the request, it is replaced with
/// the numeric block id of the forked block. Both JSON-RPC 1 and 2 semantics is covered
fn clone_call_with_origin_block_id(&self, rpc_call: &RpcMethodCall) -> RpcMethodCall {
let mut new_rpc_call = rpc_call.clone();
let origin_block_id = json!({ "block_number": self.block_number });
match new_rpc_call.params {
crate::rpc_core::request::RequestParams::None => (),
crate::rpc_core::request::RequestParams::Array(ref mut params) => {
for param in params.iter_mut() {
match param.as_str() {
Some("latest" | "pre_confirmed") => {
*param = origin_block_id;
break;
}
Some("l1_accepted") => {
tracing::warn!("Assuming fork block is ACCEPTED_ON_L1");
*param = origin_block_id;
break;
}
_ => (),
}
}
}
crate::rpc_core::request::RequestParams::Object(ref mut params) => {
if let Some(block_id) = params.get_mut("block_id") {
match block_id.as_str() {
Some("latest" | "pre_confirmed") => {
*block_id = origin_block_id;
}
Some("l1_accepted") => {
tracing::warn!("Assuming fork block is ACCEPTED_ON_L1");
*block_id = origin_block_id;
}
_ => (),
}
}
}
}
new_rpc_call
}
async fn call_with_error_handling(
&self,
rpc_call: &RpcMethodCall,
) -> Result<ResponseResult, anyhow::Error> {
let rpc_call = self.clone_call_with_origin_block_id(rpc_call);
let origin_rpc_resp: RpcResponse = self
.reqwest_client
.post(self.url.to_string())
.json(&rpc_call)
.send()
.await?
.json()
.await?;
Ok(origin_rpc_resp.result)
}
pub async fn call(&self, rpc_call: &RpcMethodCall) -> ResponseResult {
match self.call_with_error_handling(rpc_call).await {
Ok(result) => result,
Err(e) => ResponseResult::Error(RpcError::internal_error_with::<String>(format!(
"Error in interacting with origin: {e}"
))),
}
}
async fn get_l1_accepted_block(&self) -> Result<BlockWithTxHashes, ApiError> {
let tag = ImportedBlockId::Tag(ImportedBlockTag::L1Accepted);
match self.starknet_client.get_block_with_tx_hashes(tag).await {
Ok(MaybePreConfirmedBlockWithTxHashes::Block(block)) => Ok(block),
other => Err(ApiError::StarknetDevnetError(
starknet_core::error::Error::UnexpectedInternalError {
msg: format!(
"Failed retrieval of l1_accepted block from forking origin. Got: {other:?}"
),
},
)),
}
}
/// Only use with confirmed block ID
pub(crate) async fn get_block_number_from_block_id(
&self,
block_id: BlockId,
) -> Result<u64, ApiError> {
if block_id == BlockId::Tag(BlockTag::L1Accepted) {
let l1_accepted_block = self.get_l1_accepted_block().await?;
return Ok(std::cmp::min(l1_accepted_block.block_number, self.fork_block_number()));
}
match self.starknet_client.get_block_with_tx_hashes(ImportedBlockId::from(block_id)).await {
Ok(MaybePreConfirmedBlockWithTxHashes::Block(block)) => Ok(block.block_number),
Ok(MaybePreConfirmedBlockWithTxHashes::PreConfirmedBlock(block)) => {
Err(ApiError::StarknetDevnetError(
starknet_core::error::Error::UnexpectedInternalError {
msg: format!("Impossible: expected a confirmed block; got: {block:?}"),
},
))
}
Err(error) => Err(ApiError::StarknetDevnetError(
starknet_core::error::Error::UnexpectedInternalError {
msg: format!("Invalid origin response in retrieving block number: {error}"),
},
)),
}
}
}
#[cfg(test)]
mod tests {
use serde_json::json;
use super::OriginForwarder;
use crate::rpc_core::request::RpcMethodCall;
#[test]
fn test_replacing_block_id() {
let block_number = 10;
let forwarder =
OriginForwarder::new(url::Url::parse("http://dummy.com").unwrap(), block_number);
let common_body = json!({
"method": "starknet_dummyMethod",
"id": 1,
});
for (jsonrpc_value, orig_params, replaced_params) in [
("2.0", json!(null), json!(null)),
("1.0", json!(["a", 1, "latest", 2]), json!(["a", 1, { "block_number": 10 }, 2])),
(
"1.0",
json!(["a", 1, "pre_confirmed", 2]),
json!(["a", 1, { "block_number": 10 }, 2]),
),
(
"2.0",
json!({ "param1": "a", "param2": 1, "block_id": "latest", "param3": 2 }),
json!({ "param1": "a", "param2": 1, "block_id": { "block_number": 10 }, "param3": 2 }),
),
(
"2.0",
json!({ "param1": "a", "param2": 1, "block_id": "pre_confirmed", "param3": 2 }),
json!({ "param1": "a", "param2": 1, "block_id": { "block_number": 10 }, "param3": 2 }),
),
] {
let mut orig_body = common_body.clone();
orig_body["jsonrpc"] = serde_json::Value::String(jsonrpc_value.into());
orig_body["params"] = orig_params;
let request: RpcMethodCall = serde_json::from_value(orig_body).unwrap();
let replaced_request = forwarder.clone_call_with_origin_block_id(&request);
let replaced_request_json = serde_json::to_value(replaced_request).unwrap();
let mut expected_body = common_body.clone();
expected_body["jsonrpc"] = serde_json::Value::String(jsonrpc_value.into());
expected_body["params"] = replaced_params;
assert_eq!(replaced_request_json, expected_body);
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/mod.rs | crates/starknet-devnet-server/src/api/mod.rs | pub mod serde_helpers;
use std::sync::Arc;
use starknet_core::starknet::Starknet;
use starknet_core::starknet::starknet_config::StarknetConfig;
use tokio::sync::Mutex;
use tracing::error;
use crate::ServerConfig;
use crate::dump_util::DumpEvent;
use crate::subscribe::SocketCollection;
mod account_helpers;
mod endpoints;
mod endpoints_ws;
pub mod error;
pub mod json_rpc_handler;
pub mod models;
pub(crate) mod origin_forwarder;
#[cfg(test)]
mod spec_reader;
mod write_endpoints;
pub use json_rpc_handler::JsonRpcHandler;
pub const RPC_SPEC_VERSION: &str = "0.10.0";
use error::ApiError;
/// Data that can be shared between threads with read write lock access
/// Whatever needs to be accessed as information outside of Starknet could be added to this struct
#[derive(Clone)]
pub struct Api {
pub config: Arc<StarknetConfig>,
pub server_config: Arc<ServerConfig>,
pub starknet: Arc<Mutex<Starknet>>,
pub dumpable_events: Arc<Mutex<Vec<DumpEvent>>>,
pub sockets: Arc<Mutex<SocketCollection>>,
}
impl Api {
pub fn new(starknet: Starknet, server_config: ServerConfig) -> Self {
Self {
config: Arc::new(starknet.config.clone()),
server_config: Arc::new(server_config),
starknet: Arc::new(Mutex::new(starknet)),
dumpable_events: Default::default(),
sockets: Arc::new(Mutex::new(SocketCollection::default())),
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/serde_helpers.rs | crates/starknet-devnet-server/src/api/serde_helpers.rs | /// A module that deserializes `[]` and `{}` optionally
pub mod empty_params {
use serde::de::Error as DeError;
use serde::{Deserialize, Deserializer};
use serde_json::Value;
pub fn deserialize<'de, D>(d: D) -> Result<(), D::Error>
where
D: Deserializer<'de>,
{
let value: Value = Deserialize::deserialize(d)?;
match value {
Value::Null => Ok(()),
Value::Object(obj) if obj.is_empty() => Ok(()),
Value::Array(arr) if arr.is_empty() => Ok(()),
other => Err(DeError::custom(format!(
"expected empty object or array for params; got: {other:?}"
))),
}
}
}
pub mod optional_params {
use serde::de::{DeserializeOwned, Error as DeError};
use serde::{Deserialize, Deserializer};
use serde_json::Value;
pub fn deserialize<'de, D, T>(d: D) -> Result<Option<T>, D::Error>
where
D: Deserializer<'de>,
T: DeserializeOwned,
{
let value: Value = Deserialize::deserialize(d)?;
match value {
Value::Null => Ok(None),
Value::Object(obj) if obj.is_empty() => Ok(None),
Value::Array(arr) if arr.is_empty() => Ok(None),
other => Ok(Some(serde_json::from_value(other).map_err(DeError::custom)?)),
}
}
}
#[cfg(test)]
mod tests {
use serde::de::IntoDeserializer;
use serde_json::{self, Value};
use super::empty_params::deserialize;
use super::optional_params;
fn test_deserialization(json_str: &str) -> Result<(), serde_json::Error> {
let value: Value = serde_json::from_str(json_str)?;
let deserializer = value.into_deserializer();
deserialize(deserializer)
}
#[test]
fn deserialize_empty_object() {
let json_str = "{}";
assert!(test_deserialization(json_str).is_ok());
}
#[test]
fn deserialize_empty_array() {
let json_str = "[]";
assert!(test_deserialization(json_str).is_ok());
}
#[test]
fn deserialize_non_empty_object() {
let json_str = "{\"key\": \"value\"}";
assert!(test_deserialization(json_str).is_err());
}
#[test]
fn deserialize_non_empty_array() {
let json_str = "[1, 2, 3]";
assert!(test_deserialization(json_str).is_err());
}
#[test]
fn deserialize_other_types() {
let json_str = "\"string\"";
assert!(test_deserialization(json_str).is_err());
}
#[test]
fn deserialize_null() {
let value: Value = serde_json::Value::Null;
let deserializer = value.into_deserializer();
assert!(deserialize(deserializer).is_ok());
}
#[test]
fn deserialize_to_empty_object_or_with_some_data() {
let json_str = "[1, 2, 3]";
let value: Value = serde_json::from_str(json_str).unwrap();
let deserializer = value.into_deserializer();
let arr: Option<Vec<u32>> = optional_params::deserialize(deserializer).unwrap();
assert_eq!(arr, Some(vec![1, 2, 3]));
let empty_field: Option<()> =
optional_params::deserialize(Value::Null.into_deserializer()).unwrap();
assert!(empty_field.is_none());
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/write_endpoints.rs | crates/starknet-devnet-server/src/api/write_endpoints.rs | use starknet_rs_core::types::TransactionExecutionStatus;
use starknet_types::contract_address::ContractAddress;
use starknet_types::felt::{TransactionHash, felt_from_prefixed_hex};
use starknet_types::messaging::{MessageToL1, MessageToL2};
use starknet_types::rpc::block::{BlockId, BlockTag};
use starknet_types::rpc::gas_modification::GasModificationRequest;
use starknet_types::rpc::transaction_receipt::FeeUnit;
use starknet_types::rpc::transactions::l1_handler_transaction::L1HandlerTransaction;
use starknet_types::rpc::transactions::{
BroadcastedDeclareTransaction, BroadcastedDeployAccountTransaction,
BroadcastedInvokeTransaction,
};
use super::error::{ApiError, StrictRpcResult};
use super::models::{
DeclareTransactionOutput, DeployAccountTransactionOutput, DevnetResponse, JsonRpcResponse,
StarknetResponse, TransactionHashOutput,
};
use crate::api::JsonRpcHandler;
use crate::api::account_helpers::{get_balance, get_erc20_fee_unit_address};
use crate::api::models::{
AbortedBlocks, AbortingBlocks, AcceptOnL1Request, AcceptedOnL1Blocks, CreatedBlock, DumpPath,
FlushParameters, FlushedMessages, IncreaseTime, IncreaseTimeResponse, MessageHash,
MessagingLoadAddress, MintTokensRequest, MintTokensResponse, PostmanLoadL1MessagingContract,
RestartParameters, SetTime, SetTimeResponse,
};
use crate::dump_util::{dump_events, load_events};
use crate::rpc_core::error::RpcError;
use crate::rpc_core::request::RpcMethodCall;
use crate::rpc_core::response::ResponseResult;
use crate::rpc_handler::RpcHandler;
impl JsonRpcHandler {
pub async fn add_declare_transaction(
&self,
request: BroadcastedDeclareTransaction,
) -> StrictRpcResult {
let (transaction_hash, class_hash) =
self.api.starknet.lock().await.add_declare_transaction(request).map_err(
|err| match err {
starknet_core::error::Error::CompiledClassHashMismatch => {
ApiError::CompiledClassHashMismatch
}
starknet_core::error::Error::ClassAlreadyDeclared { .. } => {
ApiError::ClassAlreadyDeclared
}
starknet_core::error::Error::ContractClassSizeIsTooLarge => {
ApiError::ContractClassSizeIsTooLarge
}
unknown_error => ApiError::StarknetDevnetError(unknown_error),
},
)?;
Ok(StarknetResponse::AddDeclareTransaction(DeclareTransactionOutput {
transaction_hash,
class_hash,
})
.into())
}
pub async fn add_deploy_account_transaction(
&self,
request: BroadcastedDeployAccountTransaction,
) -> StrictRpcResult {
let (transaction_hash, contract_address) =
self.api.starknet.lock().await.add_deploy_account_transaction(request).map_err(
|err| match err {
starknet_core::error::Error::StateError(
starknet_core::error::StateError::NoneClassHash(_),
) => ApiError::ClassHashNotFound,
unknown_error => ApiError::StarknetDevnetError(unknown_error),
},
)?;
Ok(StarknetResponse::AddDeployAccountTransaction(DeployAccountTransactionOutput {
transaction_hash,
contract_address,
})
.into())
}
pub async fn add_invoke_transaction(
&self,
request: BroadcastedInvokeTransaction,
) -> StrictRpcResult {
let transaction_hash = self.api.starknet.lock().await.add_invoke_transaction(request)?;
Ok(StarknetResponse::TransactionHash(TransactionHashOutput { transaction_hash }).into())
}
/// devnet_impersonateAccount
pub async fn impersonate_account(&self, address: ContractAddress) -> StrictRpcResult {
let mut starknet = self.api.starknet.lock().await;
starknet.impersonate_account(address)?;
Ok(JsonRpcResponse::Empty)
}
/// devnet_stopImpersonateAccount
pub async fn stop_impersonating_account(&self, address: ContractAddress) -> StrictRpcResult {
let mut starknet = self.api.starknet.lock().await;
starknet.stop_impersonating_account(&address);
Ok(JsonRpcResponse::Empty)
}
/// devnet_autoImpersonate | devnet_stopAutoImpersonate
pub async fn set_auto_impersonate(&self, auto_impersonation: bool) -> StrictRpcResult {
let mut starknet = self.api.starknet.lock().await;
starknet.set_auto_impersonate_account(auto_impersonation)?;
Ok(JsonRpcResponse::Empty)
}
/// devnet_dump
pub async fn dump(&self, path: Option<DumpPath>) -> StrictRpcResult {
if self.api.config.dump_on.is_none() {
return Err(ApiError::DumpError {
msg: "Please provide --dump-on mode on startup.".to_string(),
});
}
let path = path
.as_ref()
.map(|DumpPath { path }| path.clone())
.or_else(|| self.api.config.dump_path.clone())
.unwrap_or_default();
let dumpable_events = { self.api.dumpable_events.lock().await.clone() };
if !path.is_empty() {
dump_events(&dumpable_events, &path)
.map_err(|err| ApiError::DumpError { msg: err.to_string() })?;
return Ok(DevnetResponse::DevnetDump(None).into());
}
Ok(DevnetResponse::DevnetDump(Some(dumpable_events)).into())
}
/// devnet_load
pub async fn load(&self, path: String) -> StrictRpcResult {
let events = load_events(self.api.config.dump_on, &path)?;
// Necessary to restart before loading; restarting messaging to allow re-execution
self.restart(Some(RestartParameters { restart_l1_to_l2_messaging: true })).await?;
self.re_execute(&events).await.map_err(ApiError::RpcError)?;
Ok(JsonRpcResponse::Empty)
}
/// devnet_postmanLoad
pub async fn postman_load(&self, data: PostmanLoadL1MessagingContract) -> StrictRpcResult {
let mut starknet = self.api.starknet.lock().await;
let messaging_contract_address = starknet
.configure_messaging(
&data.network_url,
data.messaging_contract_address.as_deref(),
data.deployer_account_private_key.as_deref(),
)
.await?;
Ok(DevnetResponse::MessagingContractAddress(MessagingLoadAddress {
messaging_contract_address,
})
.into())
}
/// devnet_postmanFlush
pub async fn postman_flush(&self, data: Option<FlushParameters>) -> StrictRpcResult {
let is_dry_run = if let Some(params) = data { params.dry_run } else { false };
// Need to handle L1 to L2 first in case those messages create L2 to L1 messages.
let mut messages_to_l2 = vec![];
let mut generated_l2_transactions = vec![];
if !is_dry_run {
// Fetch and execute messages to L2.
// It is important that self.api.starknet is dropped immediately to allow rpc execution
messages_to_l2 =
self.api.starknet.lock().await.fetch_messages_to_l2().await.map_err(|e| {
ApiError::RpcError(RpcError::internal_error_with(format!(
"Error in fetching messages to L2: {e}"
)))
})?;
for message in &messages_to_l2 {
let rpc_call = message.try_into().map_err(|e| {
ApiError::RpcError(RpcError::internal_error_with(format!(
"Error in converting message to L2 RPC call: {e}"
)))
})?;
let tx_hash = execute_rpc_tx(self, rpc_call).await.map_err(ApiError::RpcError)?;
generated_l2_transactions.push(tx_hash);
}
};
// Collect and send messages to L1.
let mut starknet = self.api.starknet.lock().await;
let messages_to_l1 = starknet.collect_messages_to_l1().await.map_err(|e| {
ApiError::RpcError(RpcError::internal_error_with(format!(
"Error in collecting messages to L1: {e}"
)))
})?;
let l1_provider = if is_dry_run {
"dry run".to_string()
} else {
starknet.send_messages_to_l1().await.map_err(|e| {
ApiError::RpcError(RpcError::internal_error_with(format!(
"Error in sending messages to L1: {e}"
)))
})?;
starknet.get_ethereum_url().unwrap_or("Not set".to_string())
};
let flushed_messages = FlushedMessages {
messages_to_l1,
messages_to_l2,
generated_l2_transactions,
l1_provider,
};
Ok(DevnetResponse::FlushedMessages(flushed_messages).into())
}
/// devnet_postmanSendMessageToL2
pub async fn postman_send_message_to_l2(&self, message: MessageToL2) -> StrictRpcResult {
let transaction = L1HandlerTransaction::try_from_message_to_l2(message)?;
let transaction_hash =
self.api.starknet.lock().await.add_l1_handler_transaction(transaction)?;
Ok(DevnetResponse::TransactionHash(TransactionHashOutput { transaction_hash }).into())
}
/// devnet_postmanConsumeMessageFromL2
pub async fn postman_consume_message_from_l2(&self, message: MessageToL1) -> StrictRpcResult {
let message_hash =
self.api.starknet.lock().await.consume_l2_to_l1_message(&message).await?;
Ok(DevnetResponse::MessageHash(MessageHash { message_hash }).into())
}
/// devnet_createBlock
pub async fn create_block(&self) -> StrictRpcResult {
let mut starknet = self.api.starknet.lock().await;
starknet.create_block()?;
let block = starknet.get_latest_block()?;
Ok(DevnetResponse::CreatedBlock(CreatedBlock { block_hash: block.block_hash() }).into())
}
/// devnet_abortBlocks
pub async fn abort_blocks(&self, data: AbortingBlocks) -> StrictRpcResult {
let aborted = self.api.starknet.lock().await.abort_blocks(data.starting_block_id)?;
Ok(DevnetResponse::AbortedBlocks(AbortedBlocks { aborted }).into())
}
/// devnet_acceptOnL1
pub async fn accept_on_l1(&self, data: AcceptOnL1Request) -> StrictRpcResult {
let accepted = self.api.starknet.lock().await.accept_on_l1(data.starting_block_id)?;
Ok(DevnetResponse::AcceptedOnL1Blocks(AcceptedOnL1Blocks { accepted }).into())
}
/// devnet_setGasPrice
pub async fn set_gas_price(&self, data: GasModificationRequest) -> StrictRpcResult {
let modified_gas =
self.api.starknet.lock().await.set_next_block_gas(data).map_err(ApiError::from)?;
Ok(DevnetResponse::GasModification(modified_gas).into())
}
/// devnet_restart
pub async fn restart(&self, data: Option<RestartParameters>) -> StrictRpcResult {
self.api.dumpable_events.lock().await.clear();
let restart_params = data.unwrap_or_default();
self.api.starknet.lock().await.restart(restart_params.restart_l1_to_l2_messaging)?;
self.api.sockets.lock().await.clear();
Ok(JsonRpcResponse::Empty)
}
/// devnet_setTime
pub async fn set_time(&self, data: SetTime) -> StrictRpcResult {
let mut starknet = self.api.starknet.lock().await;
let generate_block = data.generate_block.unwrap_or(true);
starknet.set_time(data.time, generate_block)?;
let block_hash = if generate_block {
let last_block = starknet.get_latest_block()?;
Some(last_block.block_hash())
} else {
None
};
Ok(DevnetResponse::SetTime(SetTimeResponse { block_timestamp: data.time, block_hash })
.into())
}
/// devnet_increaseTime
pub async fn increase_time(&self, data: IncreaseTime) -> StrictRpcResult {
let mut starknet = self.api.starknet.lock().await;
starknet.increase_time(data.time)?;
let last_block = starknet.get_latest_block()?;
Ok(DevnetResponse::IncreaseTime(IncreaseTimeResponse {
timestamp_increased_by: data.time,
block_hash: last_block.block_hash(),
})
.into())
}
/// devnet_mint
pub async fn mint(&self, request: MintTokensRequest) -> StrictRpcResult {
let mut starknet = self.api.starknet.lock().await;
let unit = request.unit.unwrap_or(FeeUnit::FRI);
let erc20_address = get_erc20_fee_unit_address(&unit);
// increase balance
let tx_hash = starknet.mint(request.address, request.amount, erc20_address).await?;
let tx = starknet.get_transaction_execution_and_finality_status(tx_hash)?;
match tx.execution_status {
TransactionExecutionStatus::Succeeded => {
let new_balance = get_balance(
&mut starknet,
request.address,
erc20_address,
BlockId::Tag(BlockTag::PreConfirmed),
)?;
let new_balance = new_balance.to_str_radix(10);
Ok(DevnetResponse::MintTokens(MintTokensResponse { new_balance, unit, tx_hash })
.into())
}
TransactionExecutionStatus::Reverted => Err(ApiError::MintingReverted {
tx_hash,
revert_reason: tx.failure_reason.map(|reason| {
if reason.contains("u256_add Overflow") {
"The requested minting amount overflows the token contract's total_supply."
.into()
} else {
reason
}
}),
}),
}
}
}
async fn execute_rpc_tx(
rpc_handler: &JsonRpcHandler,
rpc_call: RpcMethodCall,
) -> Result<TransactionHash, RpcError> {
match rpc_handler.on_call(rpc_call).await.result {
ResponseResult::Success(result) => {
let tx_hash_hex = result
.get("transaction_hash")
.ok_or(RpcError::internal_error_with(format!(
"Message execution did not yield a transaction hash: {result:?}"
)))?
.as_str()
.ok_or(RpcError::internal_error_with(format!(
"Message execution result contains invalid transaction hash: {result:?}"
)))?;
let tx_hash = felt_from_prefixed_hex(tx_hash_hex).map_err(|e| {
RpcError::internal_error_with(format!(
"Message execution resulted in an invalid tx hash: {tx_hash_hex}: {e}"
))
})?;
Ok(tx_hash)
}
ResponseResult::Error(e) => Err(e),
}
}
#[cfg(test)]
mod tests {
use crate::api::models::BroadcastedDeployAccountTransactionEnumWrapper;
#[test]
fn check_correct_deserialization_of_deploy_account_transaction_request() {
let _: BroadcastedDeployAccountTransactionEnumWrapper = serde_json::from_str(
r#"{
"type":"DEPLOY_ACCOUNT",
"resource_bounds": {
"l1_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l1_data_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l2_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
}
},
"tip": "0xabc",
"paymaster_data": [],
"version": "0x3",
"signature": ["0xFF", "0xAA"],
"nonce": "0x0",
"contract_address_salt": "0x01",
"class_hash": "0x01",
"constructor_calldata": ["0x01"],
"nonce_data_availability_mode": "L1",
"fee_data_availability_mode": "L1"
}"#,
)
.unwrap();
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/models/json_rpc_response.rs | crates/starknet-devnet-server/src/api/models/json_rpc_response.rs | #[cfg(test)]
use serde::Deserialize;
use serde::Serialize;
use starknet_core::CasmContractClass;
use starknet_rs_core::types::{ContractClass as CodegenContractClass, Felt};
use starknet_types::rpc::block::{Block, PreConfirmedBlock};
use starknet_types::rpc::estimate_message_fee::FeeEstimateWrapper;
use starknet_types::rpc::gas_modification::GasModification;
use starknet_types::rpc::state::{PreConfirmedStateUpdate, StateUpdate};
use starknet_types::rpc::transaction_receipt::TransactionReceipt;
use starknet_types::rpc::transactions::{
BlockTransactionTrace, EventsChunk, L1HandlerTransactionStatus, SimulatedTransaction,
TransactionStatus, TransactionTrace, TransactionWithHash,
};
use starknet_types::starknet_api::block::BlockNumber;
use crate::api::models::{
AbortedBlocks, AcceptedOnL1Blocks, AccountBalanceResponse, BlockHashAndNumberOutput,
CreatedBlock, DeclareTransactionOutput, DeployAccountTransactionOutput, DumpResponseBody,
FlushedMessages, IncreaseTimeResponse, MessageHash, MessagingLoadAddress, MintTokensResponse,
SerializableAccount, SetTimeResponse, SyncingOutput, TransactionHashOutput,
};
use crate::config::DevnetConfig;
#[derive(Serialize)]
#[serde(untagged)]
#[allow(clippy::large_enum_variant)]
pub enum JsonRpcResponse {
Starknet(StarknetResponse),
Devnet(DevnetResponse),
Empty,
}
impl From<StarknetResponse> for JsonRpcResponse {
fn from(resp: StarknetResponse) -> Self {
JsonRpcResponse::Starknet(resp)
}
}
impl From<DevnetResponse> for JsonRpcResponse {
fn from(resp: DevnetResponse) -> Self {
JsonRpcResponse::Devnet(resp)
}
}
#[derive(Serialize)]
#[cfg_attr(test, derive(Deserialize))]
#[serde(untagged)]
#[allow(clippy::large_enum_variant)]
pub enum StarknetResponse {
Block(Block),
PreConfirmedBlock(PreConfirmedBlock),
StateUpdate(StateUpdate),
PreConfirmedStateUpdate(PreConfirmedStateUpdate),
Felt(Felt),
Transaction(TransactionWithHash),
TransactionReceiptByTransactionHash(Box<TransactionReceipt>),
TransactionStatusByHash(TransactionStatus),
ContractClass(CodegenContractClass),
CompiledCasm(CasmContractClass),
BlockTransactionCount(u64),
Call(Vec<Felt>),
EstimateFee(Vec<FeeEstimateWrapper>),
BlockNumber(BlockNumber),
BlockHashAndNumber(BlockHashAndNumberOutput),
String(String),
Syncing(SyncingOutput),
Events(EventsChunk),
AddDeclareTransaction(DeclareTransactionOutput),
AddDeployAccountTransaction(DeployAccountTransactionOutput),
TransactionHash(TransactionHashOutput),
EstimateMessageFee(FeeEstimateWrapper),
SimulateTransactions(Vec<SimulatedTransaction>),
TraceTransaction(TransactionTrace),
BlockTransactionTraces(Vec<BlockTransactionTrace>),
MessagesStatusByL1Hash(Vec<L1HandlerTransactionStatus>),
}
#[derive(Serialize)]
#[serde(untagged)]
#[allow(clippy::large_enum_variant)]
pub enum DevnetResponse {
MessagingContractAddress(MessagingLoadAddress),
FlushedMessages(FlushedMessages),
MessageHash(MessageHash),
CreatedBlock(CreatedBlock),
AbortedBlocks(AbortedBlocks),
AcceptedOnL1Blocks(AcceptedOnL1Blocks),
GasModification(GasModification),
SetTime(SetTimeResponse),
IncreaseTime(IncreaseTimeResponse),
TransactionHash(TransactionHashOutput),
PredeployedAccounts(Vec<SerializableAccount>),
AccountBalance(AccountBalanceResponse),
MintTokens(MintTokensResponse),
DevnetConfig(DevnetConfig),
DevnetDump(DumpResponseBody),
}
#[cfg(test)]
mod response_tests {
use crate::api::error::StrictRpcResult;
use crate::api::models::{JsonRpcResponse, ToRpcResponseResult};
#[test]
fn serializing_starknet_response_empty_variant_yields_empty_json_on_conversion_to_rpc_result() {
assert_eq!(
r#"{"result":{}}"#,
serde_json::to_string(&StrictRpcResult::Ok(JsonRpcResponse::Empty).to_rpc_result())
.unwrap()
);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/models/json_rpc_request.rs | crates/starknet-devnet-server/src/api/models/json_rpc_request.rs | use enum_helper_macros::{AllVariantsSerdeRenames, VariantName};
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use serde_json::json;
use starknet_types::messaging::{MessageToL1, MessageToL2};
use starknet_types::rpc::estimate_message_fee::EstimateMessageFeeRequest;
use starknet_types::rpc::gas_modification::GasModificationRequest;
use tracing::error;
use crate::api::account_helpers::{BalanceQuery, PredeployedAccountsQuery};
use crate::api::error::StrictRpcResult;
use crate::api::models::{
AbortingBlocks, AcceptOnL1Request, AccountAddressInput, BlockAndClassHashInput,
BlockAndContractAddressInput, BlockAndIndexInput, BlockIdInput,
BroadcastedDeclareTransactionInput, BroadcastedDeployAccountTransactionInput,
BroadcastedInvokeTransactionInput, CallInput, ClassHashInput, DumpPath, EstimateFeeInput,
EventsInput, EventsSubscriptionInput, FlushParameters, GetStorageInput, GetStorageProofInput,
IncreaseTime, JsonRpcResponse, L1TransactionHashInput, LoadPath, MintTokensRequest,
PostmanLoadL1MessagingContract, RestartParameters, SetTime, SimulateTransactionsInput,
SubscriptionBlockIdInput, SubscriptionIdInput, TransactionHashInput,
TransactionReceiptSubscriptionInput, TransactionSubscriptionInput,
};
use crate::api::serde_helpers::{empty_params, optional_params};
use crate::rpc_core::error::RpcError;
use crate::rpc_core::request::RpcMethodCall;
use crate::rpc_core::response::ResponseResult;
/// Helper trait to easily convert results to rpc results
pub trait ToRpcResponseResult {
fn to_rpc_result(self) -> ResponseResult;
}
/// Used when there is no defined code to use
pub const WILDCARD_RPC_ERROR_CODE: i64 = -1;
/// Converts a serializable value into a `ResponseResult`
pub fn to_rpc_result<T: Serialize>(val: T) -> ResponseResult {
match serde_json::to_value(val) {
Ok(success) => ResponseResult::Success(success),
Err(err) => {
error!("Failed serialize rpc response: {:?}", err);
ResponseResult::error(RpcError::internal_error())
}
}
}
impl ToRpcResponseResult for StrictRpcResult {
fn to_rpc_result(self) -> ResponseResult {
match self {
Ok(JsonRpcResponse::Empty) => to_rpc_result(json!({})),
Ok(JsonRpcResponse::Devnet(data)) => to_rpc_result(data),
Ok(JsonRpcResponse::Starknet(data)) => to_rpc_result(data),
Err(err) => err.api_error_to_rpc_error().into(),
}
}
}
#[derive(Deserialize, AllVariantsSerdeRenames, VariantName)]
#[cfg_attr(test, derive(Debug))]
#[serde(tag = "method", content = "params")]
pub enum StarknetSpecRequest {
#[serde(rename = "starknet_specVersion", with = "empty_params")]
SpecVersion,
#[serde(rename = "starknet_getBlockWithTxHashes")]
BlockWithTransactionHashes(BlockIdInput),
#[serde(rename = "starknet_getBlockWithTxs")]
BlockWithFullTransactions(BlockIdInput),
#[serde(rename = "starknet_getBlockWithReceipts")]
BlockWithReceipts(BlockIdInput),
#[serde(rename = "starknet_getStateUpdate")]
StateUpdate(BlockIdInput),
#[serde(rename = "starknet_getStorageAt")]
StorageAt(GetStorageInput),
#[serde(rename = "starknet_getStorageProof")]
StorageProof(GetStorageProofInput),
#[serde(rename = "starknet_getTransactionByHash")]
TransactionByHash(TransactionHashInput),
#[serde(rename = "starknet_getTransactionByBlockIdAndIndex")]
TransactionByBlockAndIndex(BlockAndIndexInput),
#[serde(rename = "starknet_getTransactionReceipt")]
TransactionReceiptByTransactionHash(TransactionHashInput),
#[serde(rename = "starknet_getTransactionStatus")]
TransactionStatusByHash(TransactionHashInput),
#[serde(rename = "starknet_getMessagesStatus")]
MessagesStatusByL1Hash(L1TransactionHashInput),
#[serde(rename = "starknet_getClass")]
ClassByHash(BlockAndClassHashInput),
#[serde(rename = "starknet_getCompiledCasm")]
CompiledCasmByClassHash(ClassHashInput),
#[serde(rename = "starknet_getClassHashAt")]
ClassHashAtContractAddress(BlockAndContractAddressInput),
#[serde(rename = "starknet_getClassAt")]
ClassAtContractAddress(BlockAndContractAddressInput),
#[serde(rename = "starknet_getBlockTransactionCount")]
BlockTransactionCount(BlockIdInput),
#[serde(rename = "starknet_call")]
Call(CallInput),
#[serde(rename = "starknet_estimateFee")]
EstimateFee(EstimateFeeInput),
#[serde(rename = "starknet_blockNumber", with = "empty_params")]
BlockNumber,
#[serde(rename = "starknet_blockHashAndNumber", with = "empty_params")]
BlockHashAndNumber,
#[serde(rename = "starknet_chainId", with = "empty_params")]
ChainId,
#[serde(rename = "starknet_syncing", with = "empty_params")]
Syncing,
#[serde(rename = "starknet_getEvents")]
Events(EventsInput),
#[serde(rename = "starknet_getNonce")]
ContractNonce(BlockAndContractAddressInput),
#[serde(rename = "starknet_addDeclareTransaction")]
AddDeclareTransaction(BroadcastedDeclareTransactionInput),
#[serde(rename = "starknet_addDeployAccountTransaction")]
AddDeployAccountTransaction(BroadcastedDeployAccountTransactionInput),
#[serde(rename = "starknet_addInvokeTransaction")]
AddInvokeTransaction(BroadcastedInvokeTransactionInput),
#[serde(rename = "starknet_estimateMessageFee")]
EstimateMessageFee(EstimateMessageFeeRequest),
#[serde(rename = "starknet_simulateTransactions")]
SimulateTransactions(SimulateTransactionsInput),
#[serde(rename = "starknet_traceTransaction")]
TraceTransaction(TransactionHashInput),
#[serde(rename = "starknet_traceBlockTransactions")]
BlockTransactionTraces(BlockIdInput),
}
#[derive(Deserialize, AllVariantsSerdeRenames, VariantName)]
#[cfg_attr(test, derive(Debug))]
#[serde(tag = "method", content = "params")]
pub enum DevnetSpecRequest {
#[serde(rename = "devnet_impersonateAccount")]
ImpersonateAccount(AccountAddressInput),
#[serde(rename = "devnet_stopImpersonateAccount")]
StopImpersonateAccount(AccountAddressInput),
#[serde(rename = "devnet_autoImpersonate", with = "empty_params")]
AutoImpersonate,
#[serde(rename = "devnet_stopAutoImpersonate", with = "empty_params")]
StopAutoImpersonate,
#[serde(rename = "devnet_dump", with = "optional_params")]
Dump(Option<DumpPath>),
#[serde(rename = "devnet_load")]
Load(LoadPath),
#[serde(rename = "devnet_postmanLoad")]
PostmanLoadL1MessagingContract(PostmanLoadL1MessagingContract),
#[serde(rename = "devnet_postmanFlush", with = "optional_params")]
PostmanFlush(Option<FlushParameters>),
#[serde(rename = "devnet_postmanSendMessageToL2")]
PostmanSendMessageToL2(MessageToL2),
#[serde(rename = "devnet_postmanConsumeMessageFromL2")]
PostmanConsumeMessageFromL2(MessageToL1),
#[serde(rename = "devnet_createBlock", with = "empty_params")]
CreateBlock,
#[serde(rename = "devnet_abortBlocks")]
AbortBlocks(AbortingBlocks),
#[serde(rename = "devnet_acceptOnL1")]
AcceptOnL1(AcceptOnL1Request),
#[serde(rename = "devnet_setGasPrice")]
SetGasPrice(GasModificationRequest),
#[serde(rename = "devnet_restart", with = "optional_params")]
Restart(Option<RestartParameters>),
#[serde(rename = "devnet_setTime")]
SetTime(SetTime),
#[serde(rename = "devnet_increaseTime")]
IncreaseTime(IncreaseTime),
#[serde(rename = "devnet_getPredeployedAccounts", with = "optional_params")]
PredeployedAccounts(Option<PredeployedAccountsQuery>),
#[serde(rename = "devnet_getAccountBalance")]
AccountBalance(BalanceQuery),
#[serde(rename = "devnet_mint")]
Mint(MintTokensRequest),
#[serde(rename = "devnet_getConfig", with = "empty_params")]
DevnetConfig,
}
#[cfg_attr(test, derive(Debug))]
pub enum JsonRpcRequest {
StarknetSpecRequest(StarknetSpecRequest),
DevnetSpecRequest(DevnetSpecRequest),
// If adding a new variant, expand `fn deserialize` and `fn all_variants_serde_renames`
}
impl<'de> Deserialize<'de> for JsonRpcRequest {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let raw_req = serde_json::Value::deserialize(deserializer)?;
let method = raw_req.get("method").and_then(|m| m.as_str()).unwrap_or("<missing>");
match method {
method if method.starts_with("starknet_") => Ok(Self::StarknetSpecRequest(
serde_json::from_value(raw_req).map_err(serde::de::Error::custom)?,
)),
method if method.starts_with("devnet_") => Ok(Self::DevnetSpecRequest(
serde_json::from_value(raw_req).map_err(serde::de::Error::custom)?,
)),
invalid => Err(serde::de::Error::custom(format!("Invalid method: {invalid}"))),
}
}
}
impl StarknetSpecRequest {
pub fn requires_notifying(&self) -> bool {
#![warn(clippy::wildcard_enum_match_arm)]
match self {
Self::AddDeclareTransaction(_)
| Self::AddDeployAccountTransaction(_)
| Self::AddInvokeTransaction(_) => true,
Self::SpecVersion
| Self::BlockWithTransactionHashes(_)
| Self::BlockWithFullTransactions(_)
| Self::BlockWithReceipts(_)
| Self::StateUpdate(_)
| Self::StorageAt(_)
| Self::TransactionByHash(_)
| Self::TransactionByBlockAndIndex(_)
| Self::TransactionReceiptByTransactionHash(_)
| Self::TransactionStatusByHash(_)
| Self::MessagesStatusByL1Hash(_)
| Self::ClassByHash(_)
| Self::CompiledCasmByClassHash(_)
| Self::ClassHashAtContractAddress(_)
| Self::ClassAtContractAddress(_)
| Self::BlockTransactionCount(_)
| Self::Call(_)
| Self::EstimateFee(_)
| Self::BlockNumber
| Self::BlockHashAndNumber
| Self::ChainId
| Self::Syncing
| Self::Events(_)
| Self::ContractNonce(_)
| Self::EstimateMessageFee(_)
| Self::SimulateTransactions(_)
| Self::TraceTransaction(_)
| Self::BlockTransactionTraces(_)
| Self::StorageProof(_) => false,
}
}
pub fn is_forwardable_to_origin(&self) -> bool {
#[warn(clippy::wildcard_enum_match_arm)]
match self {
Self::BlockWithTransactionHashes(_)
| Self::BlockWithFullTransactions(_)
| Self::BlockWithReceipts(_)
| Self::StateUpdate(_)
| Self::StorageAt(_)
| Self::TransactionByHash(_)
| Self::TransactionByBlockAndIndex(_)
| Self::TransactionReceiptByTransactionHash(_)
| Self::TransactionStatusByHash(_)
| Self::ClassByHash(_)
| Self::ClassHashAtContractAddress(_)
| Self::ClassAtContractAddress(_)
| Self::BlockTransactionCount(_)
| Self::Call(_)
| Self::EstimateFee(_)
| Self::BlockNumber
| Self::BlockHashAndNumber
| Self::Events(_)
| Self::ContractNonce(_)
| Self::EstimateMessageFee(_)
| Self::SimulateTransactions(_)
| Self::TraceTransaction(_)
| Self::MessagesStatusByL1Hash(_)
| Self::CompiledCasmByClassHash(_)
| Self::StorageProof(_)
| Self::BlockTransactionTraces(_) => true,
Self::SpecVersion
| Self::ChainId
| Self::Syncing
| Self::AddDeclareTransaction(_)
| Self::AddDeployAccountTransaction(_)
| Self::AddInvokeTransaction(_) => false,
}
}
pub fn is_dumpable(&self) -> bool {
#[warn(clippy::wildcard_enum_match_arm)]
match self {
Self::AddDeclareTransaction(_)
| Self::AddDeployAccountTransaction(_)
| Self::AddInvokeTransaction(_) => true,
Self::SpecVersion
| Self::BlockWithTransactionHashes(_)
| Self::BlockWithFullTransactions(_)
| Self::BlockWithReceipts(_)
| Self::StateUpdate(_)
| Self::StorageAt(_)
| Self::TransactionByHash(_)
| Self::TransactionByBlockAndIndex(_)
| Self::TransactionReceiptByTransactionHash(_)
| Self::TransactionStatusByHash(_)
| Self::ClassByHash(_)
| Self::ClassHashAtContractAddress(_)
| Self::ClassAtContractAddress(_)
| Self::BlockTransactionCount(_)
| Self::Call(_)
| Self::EstimateFee(_)
| Self::BlockNumber
| Self::BlockHashAndNumber
| Self::ChainId
| Self::Syncing
| Self::Events(_)
| Self::ContractNonce(_)
| Self::EstimateMessageFee(_)
| Self::SimulateTransactions(_)
| Self::TraceTransaction(_)
| Self::BlockTransactionTraces(_)
| Self::MessagesStatusByL1Hash(_)
| Self::CompiledCasmByClassHash(_)
| Self::StorageProof(_) => false,
}
}
}
impl DevnetSpecRequest {
pub fn requires_notifying(&self) -> bool {
#![warn(clippy::wildcard_enum_match_arm)]
match self {
Self::PostmanFlush(_)
| Self::PostmanSendMessageToL2(_)
| Self::CreateBlock
| Self::AbortBlocks(_)
| Self::AcceptOnL1(_)
| Self::SetTime(_)
| Self::IncreaseTime(_)
| Self::Mint(_) => true,
Self::ImpersonateAccount(_)
| Self::StopImpersonateAccount(_)
| Self::AutoImpersonate
| Self::StopAutoImpersonate
| Self::Dump(_)
| Self::Load(_)
| Self::PostmanLoadL1MessagingContract(_)
| Self::PostmanConsumeMessageFromL2(_)
| Self::SetGasPrice(_)
| Self::Restart(_)
| Self::PredeployedAccounts(_)
| Self::AccountBalance(_)
| Self::DevnetConfig => false,
}
}
/// postmanFlush not dumped because it creates new RPC calls which get dumped
pub fn is_dumpable(&self) -> bool {
#[warn(clippy::wildcard_enum_match_arm)]
match self {
Self::ImpersonateAccount(_)
| Self::StopImpersonateAccount(_)
| Self::AutoImpersonate
| Self::StopAutoImpersonate
| Self::PostmanLoadL1MessagingContract(_)
| Self::PostmanSendMessageToL2(_)
| Self::PostmanConsumeMessageFromL2(_)
| Self::CreateBlock
| Self::AbortBlocks(_)
| Self::AcceptOnL1(_)
| Self::SetGasPrice(_)
| Self::SetTime(_)
| Self::IncreaseTime(_)
| Self::Mint(_) => true,
Self::Dump(_)
| Self::Load(_)
| Self::PostmanFlush(_)
| Self::Restart(_)
| Self::PredeployedAccounts(_)
| Self::AccountBalance(_)
| Self::DevnetConfig => false,
}
}
}
impl JsonRpcRequest {
pub fn requires_notifying(&self) -> bool {
#![warn(clippy::wildcard_enum_match_arm)]
match self {
Self::StarknetSpecRequest(req) => req.requires_notifying(),
Self::DevnetSpecRequest(req) => req.requires_notifying(),
}
}
/// Should the request be retried by being forwarded to the forking origin?
pub fn is_forwardable_to_origin(&self) -> bool {
#[warn(clippy::wildcard_enum_match_arm)]
match self {
Self::StarknetSpecRequest(req) => req.is_forwardable_to_origin(),
Self::DevnetSpecRequest(_) => false,
}
}
pub fn is_dumpable(&self) -> bool {
#[warn(clippy::wildcard_enum_match_arm)]
match self {
Self::StarknetSpecRequest(req) => req.is_dumpable(),
Self::DevnetSpecRequest(req) => req.is_dumpable(),
}
}
pub fn all_variants_serde_renames() -> Vec<String> {
let mut all_variants = vec![];
for variants in [
StarknetSpecRequest::all_variants_serde_renames(),
DevnetSpecRequest::all_variants_serde_renames(),
] {
all_variants.extend(variants);
}
all_variants
}
}
pub enum JsonRpcWsRequest {
OneTimeRequest(Box<JsonRpcRequest>),
SubscriptionRequest(JsonRpcSubscriptionRequest),
}
impl<'de> Deserialize<'de> for JsonRpcWsRequest {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let raw_req = serde_json::Value::deserialize(deserializer)?;
let method = raw_req.get("method").and_then(|m| m.as_str()).unwrap_or("<missing>");
if method.starts_with("starknet_subscribe") || method == "starknet_unsubscribe" {
Ok(Self::SubscriptionRequest(
serde_json::from_value(raw_req).map_err(serde::de::Error::custom)?,
))
} else {
Ok(Self::OneTimeRequest(
serde_json::from_value(raw_req).map_err(serde::de::Error::custom)?,
))
}
}
}
#[derive(Deserialize, AllVariantsSerdeRenames, VariantName)]
#[cfg_attr(test, derive(Debug))]
#[serde(tag = "method", content = "params")]
pub enum JsonRpcSubscriptionRequest {
#[serde(rename = "starknet_subscribeNewHeads", with = "optional_params")]
NewHeads(Option<SubscriptionBlockIdInput>),
#[serde(rename = "starknet_subscribeTransactionStatus")]
TransactionStatus(TransactionHashInput),
#[serde(rename = "starknet_subscribeEvents")]
Events(Option<EventsSubscriptionInput>),
#[serde(rename = "starknet_subscribeNewTransactions", with = "optional_params")]
NewTransactions(Option<TransactionSubscriptionInput>),
#[serde(rename = "starknet_subscribeNewTransactionReceipts", with = "optional_params")]
NewTransactionReceipts(Option<TransactionReceiptSubscriptionInput>),
#[serde(rename = "starknet_unsubscribe")]
Unsubscribe(SubscriptionIdInput),
}
pub fn to_json_rpc_request<D>(call: &RpcMethodCall) -> Result<D, RpcError>
where
D: DeserializeOwned,
{
let params: serde_json::Value = call.params.clone().into();
let deserializable_call = json!({
"method": call.method,
"params": params
});
serde_json::from_value::<D>(deserializable_call).map_err(|err| {
let err = err.to_string();
// since JSON-RPC specification requires returning a Method Not Found error,
// we apply a hacky way to decide - checking the stringified error message
if err.contains("Invalid method") || err.contains(&format!("unknown variant `{}`", call.method)) {
error!(target: "rpc", method = ?call.method, "failed to deserialize RPC call: unknown method");
RpcError::method_not_found()
} else {
error!(target: "rpc", method = ?call.method, ?err, "failed to deserialize RPC call: invalid params");
RpcError::invalid_params(err)
}
})
}
impl std::fmt::Display for JsonRpcRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let variant_name = match self {
Self::StarknetSpecRequest(req) => req.variant_name(),
Self::DevnetSpecRequest(req) => req.variant_name(),
};
write!(f, "{}", variant_name)
}
}
#[cfg(test)]
mod requests_tests {
use serde_json::json;
use starknet_types::felt::felt_from_prefixed_hex;
use super::{JsonRpcRequest, StarknetSpecRequest};
use crate::rpc_core::request::RpcMethodCall;
use crate::test_utils::{EXPECTED_INVALID_BLOCK_ID_MSG, assert_contains};
#[test]
fn deserialize_get_block_with_transaction_hashes_request() {
let json_str =
r#"{"method":"starknet_getBlockWithTxHashes","params":{"block_id":"latest"}}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_succeeds(&json_str.replace("latest", "pre_confirmed"));
assert_deserialization_fails(&json_str.replace("latest", "0x134134"), "Invalid block ID");
}
#[test]
fn deserialize_get_block_with_transactions_request() {
let json_str = r#"{"method":"starknet_getBlockWithTxs","params":{"block_id":"latest"}}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_succeeds(&json_str.replace("latest", "pre_confirmed"));
assert_deserialization_fails(
json_str.replace("latest", "0x134134").as_str(),
EXPECTED_INVALID_BLOCK_ID_MSG,
);
}
#[test]
fn deserialize_get_state_update_request() {
let json_str = r#"{"method":"starknet_getStateUpdate","params":{"block_id":"latest"}}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_succeeds(&json_str.replace("latest", "pre_confirmed"));
assert_deserialization_fails(
&json_str.replace("latest", "0x134134"),
EXPECTED_INVALID_BLOCK_ID_MSG,
);
}
#[test]
fn deserialize_get_storage_at_request() {
let json_str = r#"{"method":"starknet_getStorageAt","params":{"contract_address":"0x134134","key":"0x134134","block_id":"latest"}}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_fails(
&json_str.replace(r#""contract_address":"0x134134""#, r#""contract_address":"123""#),
"Missing prefix 0x in 123",
);
assert_deserialization_fails(
&json_str.replace(r#""contract_address":"0x134134""#, r#""contract_address": 123"#),
"invalid type: number, expected a string",
);
}
#[test]
fn deserialize_get_transaction_by_hash_request() {
let json_str = r#"{"method":"starknet_getTransactionByHash","params":{"transaction_hash":"0x134134"}}"#;
let request = serde_json::from_str::<JsonRpcRequest>(json_str).unwrap();
match request {
JsonRpcRequest::StarknetSpecRequest(StarknetSpecRequest::TransactionByHash(input)) => {
assert!(input.transaction_hash == felt_from_prefixed_hex("0x134134").unwrap());
}
_ => panic!("Wrong request type"),
}
// Errored json, there is no object just string is passed
assert_deserialization_fails(
r#"{"method":"starknet_getTransactionByHash","params":"0x134134"}"#,
"invalid type: string \"0x134134\", expected struct",
);
// Errored json, hash is not prefixed with 0x
assert_deserialization_fails(
r#"{"method":"starknet_getTransactionByHash","params":{"transaction_hash":"134134"}}"#,
"expected hex string to be prefixed by '0x'",
);
// Errored json, hex longer than 64 chars; misleading error message coming from dependency
assert_deserialization_fails(
r#"{"method":"starknet_getTransactionByHash","params":{"transaction_hash":"0x004134134134134134134134134134134134134134134134134134134134134134"}}"#,
"expected hex string to be prefixed by '0x'",
);
}
#[test]
fn deserialize_get_transaction_by_block_and_index_request() {
let json_str = r#"{"method":"starknet_getTransactionByBlockIdAndIndex","params":{"block_id":"latest","index":0}}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_fails(
json_str.replace('0', "\"0x1\"").as_str(),
"invalid type: string \"0x1\", expected u64",
);
}
#[test]
fn deserialize_get_transaction_receipt_request() {
let json_str = r#"{"method":"starknet_getTransactionReceipt","params":{"transaction_hash":"0xAAABB"}}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_fails(
json_str.replace("0x", "").as_str(),
"expected hex string to be prefixed by '0x'",
);
}
#[test]
fn deserialize_get_class_request() {
let json_str = r#"{"method":"starknet_getClass","params":{"block_id":"latest","class_hash":"0xAAABB"}}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_fails(
json_str.replace("0x", "").as_str(),
"expected hex string to be prefixed by '0x'",
);
}
#[test]
fn deserialize_get_class_hash_at_request() {
let json_str = r#"{"method":"starknet_getClassHashAt","params":{"block_id":"latest","contract_address":"0xAAABB"}}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_fails(
json_str.replace("0x", "").as_str(),
"Error converting from hex string",
);
}
#[test]
fn deserialize_get_class_at_request() {
let json_str = r#"{"method":"starknet_getClassAt","params":{"block_id":"latest","contract_address":"0xAAABB"}}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_fails(json_str.replace("0x", "").as_str(), "Missing prefix 0x");
}
#[test]
fn deserialize_get_block_transaction_count_request() {
let json_str =
r#"{"method":"starknet_getBlockTransactionCount","params":{"block_id":"latest"}}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_fails(
json_str.replace("latest", "0x134134").as_str(),
EXPECTED_INVALID_BLOCK_ID_MSG,
);
}
#[test]
fn deserialize_call_request() {
let json_str = r#"{
"method":"starknet_call",
"params":{
"block_id":"latest",
"request":{
"contract_address":"0xAAABB",
"entry_point_selector":"0x134134",
"calldata":["0x134134"]
}
}
}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_fails(
json_str.replace("starknet_call", "starknet_Call").as_str(),
"unknown variant `starknet_Call`",
);
assert_deserialization_fails(
json_str
.replace(r#""contract_address":"0xAAABB""#, r#""contract_address":"123""#)
.as_str(),
"Error converting from hex string",
);
assert_deserialization_fails(
json_str
.replace(
r#""entry_point_selector":"0x134134""#,
r#""entry_point_selector":"134134""#,
)
.as_str(),
"expected hex string to be prefixed by '0x'",
);
assert_deserialization_fails(
json_str.replace(r#""calldata":["0x134134"]"#, r#""calldata":["123"]"#).as_str(),
"expected hex string to be prefixed by '0x'",
);
assert_deserialization_fails(
json_str.replace(r#""calldata":["0x134134"]"#, r#""calldata":[123]"#).as_str(),
"invalid type: number, expected a 32 byte array ([u8;32]) or a hexadecimal string",
);
}
#[test]
fn deserialize_deploy_account_fee_estimation_request() {
let json_str = r#"{
"method":"starknet_estimateFee",
"params":{
"block_id":"latest",
"simulation_flags": [],
"request":[
{
"type":"DEPLOY_ACCOUNT",
"resource_bounds": {
"l1_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l1_data_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l2_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
}
},
"tip": "0xabc",
"paymaster_data": [],
"version": "0x100000000000000000000000000000003",
"signature": ["0xFF", "0xAA"],
"nonce": "0x0",
"contract_address_salt": "0x01",
"class_hash": "0x01",
"constructor_calldata": ["0x01"],
"nonce_data_availability_mode": "L1",
"fee_data_availability_mode": "L1"
}
]
}
}"#;
assert_deserialization_succeeds(json_str);
assert_deserialization_fails(
json_str.replace("estimateFee", "estimate_fee").as_str(),
"unknown variant `starknet_estimate_fee`",
);
}
fn sample_declare_v3_body() -> serde_json::Value {
json!({
"type":"DECLARE",
"version": "0x3",
"signature": [
"0x2216f8f4d9abc06e130d2a05b13db61850f0a1d21891c7297b98fd6cc51920d",
"0x6aadfb198bbffa8425801a2342f5c6d804745912114d5976f53031cd789bb6d"
],
"resource_bounds": {
"l1_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l1_data_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l2_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
}
},
"tip": "0xabc",
"paymaster_data": [],
"account_deployment_data": [],
"nonce": "0x0",
"compiled_class_hash":"0x63b33a5f2f46b1445d04c06d7832c48c48ad087ce0803b71f2b8d96353716ca",
"sender_address":"0x34ba56f92265f0868c57d3fe72ecab144fc96f97954bbbc4252cef8e8a979ba",
"contract_class": {
"sierra_program": ["0xAA", "0xBB"],
"entry_points_by_type": {
"EXTERNAL": [{"function_idx":0,"selector":"0x362398bec32bc0ebb411203221a35a0301193a96f317ebe5e40be9f60d15320"},{"function_idx":1,"selector":"0x39e11d48192e4333233c7eb19d10ad67c362bb28580c604d67884c85da39695"}],
"L1_HANDLER": [],
"CONSTRUCTOR": [{"function_idx":2,"selector":"0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194"}]
},
"abi": "[{\"type\": \"function\", \"name\": \"constructor\", \"inputs\": [{\"name\": \"initial_balance\", \"type\": \"core::felt252\"}], \"outputs\": [], \"state_mutability\": \"external\"}, {\"type\": \"function\", \"name\": \"increase_balance\", \"inputs\": [{\"name\": \"amount1\", \"type\": \"core::felt252\"}, {\"name\": \"amount2\", \"type\": \"core::felt252\"}], \"outputs\": [], \"state_mutability\": \"external\"}, {\"type\": \"function\", \"name\": \"get_balance\", \"inputs\": [], \"outputs\": [{\"type\": \"core::felt252\"}], \"state_mutability\": \"view\"}]",
"contract_class_version": "0.1.0"
},
"nonce_data_availability_mode": "L1",
"fee_data_availability_mode": "L1"
})
}
fn create_declare_request(tx: serde_json::Value) -> serde_json::Value {
json!({
"method":"starknet_addDeclareTransaction",
"params":{
"declare_transaction": tx
}
})
}
fn create_estimate_request(requests: &[serde_json::Value]) -> serde_json::Value {
json!({
"method": "starknet_estimateFee",
"params": {
"block_id": "latest",
"simulation_flags": [],
"request": requests
}
})
}
#[test]
fn deserialize_declare_v3_fee_estimation_request() {
assert_deserialization_succeeds(
&create_estimate_request(&[sample_declare_v3_body()]).to_string(),
);
assert_deserialization_succeeds(
&create_estimate_request(&[sample_declare_v3_body()]).to_string().replace(
r#""version":"0x3""#,
r#""version":"0x100000000000000000000000000000003""#,
),
);
}
#[test]
fn deserialize_get_events_request() {
let json_str = r#"{
"method":"starknet_getEvents",
"params":{
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | true |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/models/mod.rs | crates/starknet-devnet-server/src/api/models/mod.rs | mod json_rpc_request;
mod json_rpc_response;
pub use json_rpc_request::{
DevnetSpecRequest, JsonRpcRequest, JsonRpcSubscriptionRequest, JsonRpcWsRequest,
StarknetSpecRequest, ToRpcResponseResult, WILDCARD_RPC_ERROR_CODE, to_json_rpc_request,
};
pub use json_rpc_response::{DevnetResponse, JsonRpcResponse, StarknetResponse};
use serde::{Deserialize, Serialize};
use starknet_rs_core::types::{Felt, Hash256, TransactionExecutionStatus};
use starknet_types::contract_address::ContractAddress;
use starknet_types::felt::{BlockHash, ClassHash, TransactionHash};
use starknet_types::num_bigint::BigUint;
use starknet_types::patricia_key::PatriciaKey;
use starknet_types::rpc::block::{BlockId, SubscriptionBlockId};
use starknet_types::rpc::messaging::{MessageToL1, MessageToL2};
use starknet_types::rpc::transaction_receipt::FeeUnit;
use starknet_types::rpc::transactions::{
BroadcastedDeclareTransaction, BroadcastedDeployAccountTransaction,
BroadcastedInvokeTransaction, BroadcastedTransaction, EventFilter, FunctionCall,
SimulationFlag, TransactionFinalityStatus,
};
use starknet_types::serde_helpers::dec_string::deserialize_biguint;
use starknet_types::starknet_api::block::BlockNumber;
use crate::rpc_core::request::RpcMethodCall;
use crate::subscribe::{TransactionFinalityStatusWithoutL1, TransactionStatusWithoutL1};
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BlockIdInput {
pub block_id: BlockId,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TransactionHashInput {
pub transaction_hash: TransactionHash,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct ClassHashInput {
pub class_hash: ClassHash,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
#[cfg_attr(test, derive(PartialEq, Eq))]
pub struct GetStorageInput {
pub contract_address: ContractAddress,
pub key: PatriciaKey,
pub block_id: BlockId,
}
#[derive(Deserialize, Clone, Debug)]
pub struct ContractStorage {
pub contract_address: ContractAddress,
pub storage_keys: Vec<Felt>,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct GetStorageProofInput {
pub block_id: BlockId,
pub class_hashes: Option<Vec<Felt>>,
pub contract_addresses: Option<Vec<ContractAddress>>,
pub contracts_storage_keys: Option<Vec<ContractStorage>>,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BlockAndIndexInput {
pub block_id: BlockId,
pub index: u64,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BlockAndClassHashInput {
pub block_id: BlockId,
pub class_hash: ClassHash,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct BlockAndContractAddressInput {
pub block_id: BlockId,
pub contract_address: ContractAddress,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct AccountAddressInput {
pub account_address: ContractAddress,
}
#[derive(Debug, Clone, Deserialize)]
#[cfg_attr(test, derive(PartialEq, Eq))]
#[serde(deny_unknown_fields)]
pub struct CallInput {
pub request: FunctionCall,
pub block_id: BlockId,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct EstimateFeeInput {
pub request: Vec<BroadcastedTransaction>,
pub simulation_flags: Vec<SimulationFlag>,
pub block_id: BlockId,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(test, derive(Deserialize))]
#[serde(deny_unknown_fields)]
pub struct BlockHashAndNumberOutput {
pub block_hash: BlockHash,
pub block_number: BlockNumber,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(test, derive(Deserialize))]
#[serde(untagged)]
pub enum SyncingOutput {
False(bool), // if it seems redundant, check the spec
}
#[derive(Debug, Clone, Deserialize)]
pub struct EventsInput {
pub filter: EventFilter,
}
#[derive(Deserialize, Debug, Clone)]
#[serde(tag = "type")]
pub enum BroadcastedDeclareTransactionEnumWrapper {
#[serde(rename = "DECLARE")]
Declare(BroadcastedDeclareTransaction),
}
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BroadcastedDeclareTransactionInput {
pub declare_transaction: BroadcastedDeclareTransactionEnumWrapper,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(test, derive(Deserialize))]
#[serde(deny_unknown_fields)]
pub struct DeclareTransactionOutput {
pub transaction_hash: TransactionHash,
pub class_hash: ClassHash,
}
#[derive(Deserialize, Debug, Clone)]
#[serde(tag = "type")]
pub enum BroadcastedDeployAccountTransactionEnumWrapper {
#[serde(rename = "DEPLOY_ACCOUNT")]
DeployAccount(BroadcastedDeployAccountTransaction),
}
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BroadcastedDeployAccountTransactionInput {
pub deploy_account_transaction: BroadcastedDeployAccountTransactionEnumWrapper,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(test, derive(Deserialize))]
#[serde(deny_unknown_fields)]
pub struct DeployAccountTransactionOutput {
pub transaction_hash: TransactionHash,
pub contract_address: ContractAddress,
}
#[derive(Deserialize, Debug, Clone)]
#[serde(tag = "type", rename_all = "SCREAMING_SNAKE_CASE")]
pub enum BroadcastedInvokeTransactionEnumWrapper {
Invoke(BroadcastedInvokeTransaction),
}
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BroadcastedInvokeTransactionInput {
pub invoke_transaction: BroadcastedInvokeTransactionEnumWrapper,
}
#[derive(Debug, Clone, Serialize)]
#[cfg_attr(test, derive(Deserialize))]
#[serde(deny_unknown_fields)]
pub struct TransactionHashOutput {
pub transaction_hash: TransactionHash,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SimulateTransactionsInput {
pub block_id: BlockId,
pub transactions: Vec<BroadcastedTransaction>,
pub simulation_flags: Vec<SimulationFlag>,
}
#[derive(Debug, Serialize)]
#[cfg_attr(test, derive(Deserialize))]
#[serde(deny_unknown_fields)]
pub struct TransactionStatusOutput {
pub finality_status: TransactionFinalityStatus,
pub execution_status: TransactionExecutionStatus,
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct L1TransactionHashInput {
pub transaction_hash: Hash256,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub struct SubscriptionId(u64);
impl From<u64> for SubscriptionId {
fn from(value: u64) -> Self {
Self(value)
}
}
impl Serialize for SubscriptionId {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(&self.0.to_string())
}
}
/// Custom deserialization is needed, because subscriber initially received stringified u64 value.
impl<'de> Deserialize<'de> for SubscriptionId {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let u64_as_string = String::deserialize(deserializer)?;
let subscription_id = u64_as_string.parse::<u64>().map_err(|_| {
serde::de::Error::invalid_type(serde::de::Unexpected::Str(&u64_as_string), &"u64")
})?;
Ok(SubscriptionId(subscription_id))
}
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SubscriptionIdInput {
pub subscription_id: SubscriptionId,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct SubscriptionBlockIdInput {
pub block_id: SubscriptionBlockId,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct EventsSubscriptionInput {
pub block_id: Option<SubscriptionBlockId>,
pub from_address: Option<ContractAddress>,
pub keys: Option<Vec<Vec<Felt>>>,
pub finality_status: Option<TransactionFinalityStatus>,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TransactionSubscriptionInput {
pub sender_address: Option<Vec<ContractAddress>>,
pub finality_status: Option<Vec<TransactionStatusWithoutL1>>,
}
#[derive(Deserialize, Clone, Debug)]
#[serde(deny_unknown_fields)]
pub struct TransactionReceiptSubscriptionInput {
pub sender_address: Option<Vec<ContractAddress>>,
pub finality_status: Option<Vec<TransactionFinalityStatusWithoutL1>>,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
#[cfg_attr(test, derive(Debug))]
pub struct DumpPath {
pub path: String,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
#[cfg_attr(test, derive(Debug))]
pub struct LoadPath {
pub path: String,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
#[cfg_attr(test, derive(Debug))]
pub struct PostmanLoadL1MessagingContract {
pub network_url: String,
#[serde(alias = "address")]
pub messaging_contract_address: Option<String>,
pub deployer_account_private_key: Option<String>,
}
#[derive(Serialize)]
pub struct MessageHash {
pub message_hash: Hash256,
}
// Implemented as type alias so JSON returned doesn't have extra key
pub type DumpResponseBody = Option<Vec<RpcMethodCall>>;
#[derive(Serialize)]
pub struct CreatedBlock {
pub block_hash: BlockHash,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
#[cfg_attr(test, derive(Debug))]
pub struct AbortingBlocks {
pub(crate) starting_block_id: BlockId,
}
#[derive(Serialize)]
pub struct AbortedBlocks {
pub(crate) aborted: Vec<BlockHash>,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
#[cfg_attr(test, derive(Debug))]
pub struct AcceptOnL1Request {
pub(crate) starting_block_id: BlockId,
}
#[derive(Serialize)]
pub struct AcceptedOnL1Blocks {
pub(crate) accepted: Vec<BlockHash>,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
#[cfg_attr(test, derive(Debug))]
pub struct IncreaseTime {
pub time: u64,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
#[cfg_attr(test, derive(Debug))]
pub struct SetTime {
pub time: u64,
pub generate_block: Option<bool>,
}
#[derive(Serialize)]
pub struct SetTimeResponse {
pub block_timestamp: u64,
pub block_hash: Option<BlockHash>,
}
#[derive(Serialize)]
pub struct IncreaseTimeResponse {
pub timestamp_increased_by: u64,
pub block_hash: BlockHash,
}
#[derive(Serialize)]
pub struct SerializableAccount {
pub initial_balance: String,
pub address: ContractAddress,
pub public_key: Felt,
pub private_key: Felt,
pub balance: Option<AccountBalancesResponse>,
}
#[derive(Serialize)]
pub struct AccountBalancesResponse {
pub eth: AccountBalanceResponse,
pub strk: AccountBalanceResponse,
}
#[derive(Serialize)]
pub struct AccountBalanceResponse {
pub amount: String,
pub unit: FeeUnit,
}
#[derive(Serialize)]
pub struct FeeToken {
symbol: String,
address: ContractAddress,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
#[cfg_attr(test, derive(Debug))]
pub struct MintTokensRequest {
pub address: ContractAddress,
#[serde(deserialize_with = "deserialize_biguint")]
pub amount: BigUint,
#[serde(skip_serializing_if = "Option::is_none")]
pub unit: Option<FeeUnit>,
}
#[derive(Serialize)]
pub struct MintTokensResponse {
/// decimal repr
pub new_balance: String,
pub unit: FeeUnit,
pub tx_hash: TransactionHash,
}
#[derive(Serialize)]
pub struct ForkStatus {
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub block: Option<u64>,
}
#[derive(Serialize, Deserialize)]
pub struct FlushedMessages {
pub messages_to_l1: Vec<MessageToL1>,
pub messages_to_l2: Vec<MessageToL2>,
pub generated_l2_transactions: Vec<TransactionHash>,
pub l1_provider: String,
}
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[cfg_attr(test, derive(Debug))]
pub struct FlushParameters {
pub dry_run: bool,
}
#[derive(Serialize, Deserialize)]
pub struct MessagingLoadAddress {
pub messaging_contract_address: String,
}
#[derive(Serialize, Deserialize, Default)]
#[serde(deny_unknown_fields)]
#[cfg_attr(test, derive(Debug))]
pub struct RestartParameters {
pub restart_l1_to_l2_messaging: bool,
}
#[cfg(test)]
mod tests {
use starknet_rs_core::types::Felt;
use starknet_types::contract_address::ContractAddress;
use starknet_types::felt::felt_from_prefixed_hex;
use starknet_types::patricia_key::PatriciaKey;
use starknet_types::rpc::block::{BlockId, BlockTag};
use starknet_types::rpc::transactions::{
BroadcastedDeclareTransaction, BroadcastedTransaction,
};
use super::{BlockIdInput, EstimateFeeInput, GetStorageInput};
use crate::test_utils::{EXPECTED_INVALID_BLOCK_ID_MSG, assert_contains};
#[test]
fn errored_deserialization_of_estimate_fee_with_broadcasted_declare_transaction() {
// Errored json struct that passed DECLARE V3, but contract class is of type V1
let json_str = r#"{
"request": [{
"type": "DECLARE",
"version": "0x3",
"signature": ["0xFF", "0xAA"],
"nonce": "0x0",
"sender_address": "0x0001",
"resource_bounds": {
"l1_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l1_data_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l2_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
}
},
"compiled_class_hash": "0x01",
"tip": "0xabc",
"paymaster_data": [],
"account_deployment_data": [],
"contract_class": {
"abi": [{
"inputs": [],
"name": "getPublicKey",
"outputs": [
{
"name": "publicKey",
"type": "felt"
}
],
"stateMutability": "view",
"type": "function"
},
{
"inputs": [],
"name": "setPublicKey",
"outputs": [
{
"name": "publicKey",
"type": "felt"
}
],
"type": "function"
}],
"program": "",
"entry_points_by_type": {}
},
"nonce_data_availability_mode": "L1",
"fee_data_availability_mode": "L1"
}],
"block_id": {
"block_number": 1
}
}"#;
match serde_json::from_str::<EstimateFeeInput>(json_str) {
Err(err) => assert_contains(
&err.to_string(),
// error indicative of expecting a cairo1 class artifact
"Invalid declare transaction v3: missing field `state_mutability`",
)
.unwrap(),
other => panic!("Invalid result: {other:?}"),
}
}
#[test]
fn deserialize_estimate_fee_input() {
let json_str = r#"{
"request": [
{
"type": "DECLARE",
"version": "0x3",
"signature": ["0xFF", "0xAA"],
"nonce": "0x0",
"sender_address": "0x0001",
"resource_bounds": {
"l1_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l1_data_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l2_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
}
},
"compiled_class_hash": "0x01",
"tip": "0xabc",
"paymaster_data": [],
"account_deployment_data": [],
"contract_class": {
"sierra_program": ["0xAA", "0xBB"],
"contract_class_version": "1.0",
"entry_points_by_type": {
"EXTERNAL": [
{
"selector": "0x3c118a68e16e12e97ed25cb4901c12f4d3162818669cc44c391d8049924c14",
"function_idx": 4
},
{
"selector": "0xe7510edcf6e9f1b70f7bd1f488767b50f0363422f3c563160ab77adf62467b",
"function_idx": 7
}
],
"L1_HANDLER": [
{
"selector": "0x39edbbb129ad752107a94d40c3873cae369a46fd2fc578d075679aa67e85d12",
"function_idx": 11
}
],
"CONSTRUCTOR": [
{
"selector": "0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194",
"function_idx": 12
}
]
},
"abi": [
{
"type": "constructor",
"name": "constructor",
"inputs": [
{
"name": "arg1",
"type": "core::felt252"
},
{
"name": "arg2",
"type": "core::felt252"
}
]
}
]
},
"nonce_data_availability_mode": "L1",
"fee_data_availability_mode": "L1"
},
{
"type": "INVOKE",
"resource_bounds": {
"l1_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l1_data_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l2_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
}
},
"tip": "0xabc",
"paymaster_data": [],
"account_deployment_data": [],
"version": "0x100000000000000000000000000000003",
"signature": ["0x2"],
"nonce": "0x1",
"sender_address": "0x3",
"calldata": [
"0x1",
"0x2",
"0x3"
],
"nonce_data_availability_mode": "L1",
"fee_data_availability_mode": "L1"
},
{
"type":"DEPLOY_ACCOUNT",
"resource_bounds": {
"l1_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l1_data_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
},
"l2_gas": {
"max_amount": "0x1",
"max_price_per_unit": "0x2"
}
},
"tip": "0xabc",
"paymaster_data": [],
"version": "0x100000000000000000000000000000003",
"signature": ["0xFF", "0xAA"],
"nonce": "0x0",
"contract_address_salt": "0x01",
"class_hash": "0x01",
"constructor_calldata": ["0x01"],
"nonce_data_availability_mode": "L1",
"fee_data_availability_mode": "L1"
}
],
"block_id": {
"block_number": 1
},
"simulation_flags": []
}"#;
let estimate_fee_input = serde_json::from_str::<super::EstimateFeeInput>(json_str).unwrap();
assert_eq!(estimate_fee_input.block_id, BlockId::Number(1));
assert_eq!(estimate_fee_input.request.len(), 3);
assert!(matches!(
estimate_fee_input.request[0],
BroadcastedTransaction::Declare(BroadcastedDeclareTransaction::V3(_))
));
assert!(matches!(estimate_fee_input.request[1], BroadcastedTransaction::Invoke(_)));
assert!(matches!(estimate_fee_input.request[2], BroadcastedTransaction::DeployAccount(_)));
}
#[test]
fn deserialize_call_input() {
let json_str = r#"{"request": {"contract_address": "0x01", "entry_point_selector": "0x02", "calldata": ["0x03"]}, "block_id": {"block_number": 1}}"#;
let call_input = serde_json::from_str::<super::CallInput>(json_str).unwrap();
assert_eq!(
call_input,
super::CallInput {
request: super::FunctionCall {
contract_address: ContractAddress::new(Felt::ONE).unwrap(),
entry_point_selector: Felt::TWO,
calldata: vec![Felt::THREE],
},
block_id: BlockId::Number(1),
}
);
}
#[test]
fn deserialize_get_storage_input() {
fn assert_get_storage_input_correctness(
should_be_correct: bool,
expected_storage_input: GetStorageInput,
json_str: &str,
) {
let is_correct =
if let Ok(get_storage_input) = serde_json::from_str::<GetStorageInput>(json_str) {
get_storage_input == expected_storage_input
} else {
false
};
assert_eq!(should_be_correct, is_correct);
}
let expected_storage_input = GetStorageInput {
block_id: BlockId::Hash(Felt::ONE),
contract_address: ContractAddress::new(Felt::TWO).unwrap(),
key: PatriciaKey::new(Felt::THREE).unwrap(),
};
assert_get_storage_input_correctness(
true,
expected_storage_input.clone(),
r#"{"block_id": {"block_hash": "0x01"}, "contract_address": "0x02", "key": "0x03"}"#,
);
// Incorrect contract_address key
assert_get_storage_input_correctness(
false,
expected_storage_input.clone(),
r#"{"block_id": {"block_hash": "0x01"}, "contract_address_mock": "0x02", "key": "0x03"}"#,
);
// Incorrect key
assert_get_storage_input_correctness(
false,
expected_storage_input,
r#"{"block_id": {"block_hash": "0x01"}, "contract_address": "0x02", "keyy": "0x03"}"#,
);
}
// unit tests for TransactionHashInput deserialization
#[test]
fn deserialize_transaction_hash_input() {
assert_transaction_hash_correctness(true, "0x01", r#"{"transaction_hash": "0x01"}"#);
// Incorrect transaction_hash key
assert_transaction_hash_correctness(false, "0x01", r#"{"transaction_hashh": "0x01"}"#);
// Incorrect transaction_hash value
assert_transaction_hash_correctness(false, "0x02", r#"{"transaction_hash": "0x01"}"#);
// Incorrect transaction_hash format, should be prefixed with 0x
assert_transaction_hash_correctness(false, "0x02", r#"{"transaction_hash": "01"}"#);
}
#[test]
fn deserialize_block_id_tag_variants() {
assert_block_id_tag_correctness(true, BlockTag::Latest, r#"{"block_id": "latest"}"#);
assert_block_id_tag_correctness(
true,
BlockTag::PreConfirmed,
r#"{"block_id": "pre_confirmed"}"#,
);
// Incorrect tag
assert_block_id_tag_correctness(false, BlockTag::Latest, r#"{"block_id": "latestx"}"#);
assert_block_id_tag_correctness(false, BlockTag::Latest, r#"{"block_id": "pending"}"#);
assert_block_id_tag_correctness(
false,
BlockTag::PreConfirmed,
r#"{"block_id": "pre_confirmed_d"}"#,
);
// Incorrect key
assert_block_id_tag_correctness(false, BlockTag::Latest, r#"{"block": "latest"}"#);
assert_block_id_tag_correctness(false, BlockTag::PreConfirmed, r#"{"block": "pending"}"#);
assert_block_id_tag_correctness(
false,
BlockTag::PreConfirmed,
r#"{"block": "pre_confirmed"}"#,
);
}
#[test]
fn deserialize_block_id_block_hash_variants() {
assert_block_id_block_hash_correctness(
true,
"0x01",
r#"{"block_id": {"block_hash": "0x01"}}"#,
);
// BlockId's key is block instead of block_id
assert_block_id_block_hash_correctness(
false,
"0x01",
r#"{"block": {"block_hash": "0x01"}}"#,
);
// Incorrect block_hash key
assert_block_id_block_hash_correctness(
false,
"0x01",
r#"{"block_id": {"block_hasha": "0x01"}}"#,
);
// Incorrect block_hash value
assert_block_id_block_hash_correctness(
false,
"0x02",
r#"{"block_id": {"block_hash": "0x01"}}"#,
);
// Block hash hex value is more than 64 chars
assert_block_id_block_hash_correctness(
false,
"0x01",
r#"{"block_id": {"block_hash": "0x004134134134134134134134134134134134134134134134134134134134134134"}}"#,
);
// Block hash hex doesn't start with 0x
assert_block_id_block_hash_correctness(
false,
"0x01",
r#"{"block_id": {"block_hash": "01"}}"#,
);
}
#[test]
fn deserialize_block_id_block_number_variants() {
assert_block_id_block_number_correctness(true, 10, r#"{"block_id": {"block_number": 10}}"#);
// BlockId's key is block instead of block_id
assert_block_id_block_number_correctness(false, 10, r#"{"block": {"block_number": 10}}"#);
// Incorrect block_number key
assert_block_id_block_number_correctness(
false,
10,
r#"{"block_id": {"block_number_mock": 10}}"#,
);
// Incorrect block_number value
assert_block_id_block_number_correctness(
false,
10,
r#"{"block_id": {"block_number": "0x01"}}"#,
);
}
#[test]
fn assert_error_message_for_failed_block_id_deserialization() {
for json_str in [
r#"{"block_id": {"block_number": 10, "block_hash": "0x1"}}"#,
r#"{"block_id": {"block_number": "123"}}"#,
r#"{"block_id": {"block_number": -123}}"#,
r#"{"block_id": {"invalid_key": ""}}"#,
r#"{"block_id": {"block_hash": 123}}"#,
r#"{"block_id": {"block_hash": ""}}"#,
] {
match serde_json::from_str::<BlockIdInput>(json_str) {
Err(e) => assert_contains(&e.to_string(), EXPECTED_INVALID_BLOCK_ID_MSG).unwrap(),
other => panic!("Invalid result: {other:?}"),
}
}
}
fn assert_block_id_tag_correctness(
should_be_correct: bool,
expected_tag: BlockTag,
json_str_block_id: &str,
) {
let is_correct =
serde_json::from_str::<BlockIdInput>(json_str_block_id)
.map(|BlockIdInput { block_id }| matches!(block_id, BlockId::Tag(generated_tag) if generated_tag == expected_tag))
.unwrap_or(false);
assert_eq!(should_be_correct, is_correct);
}
fn assert_block_id_block_number_correctness(
should_be_correct: bool,
expected_block_number: u64,
json_str_block_id: &str,
) {
let is_correct =
serde_json::from_str::<BlockIdInput>(json_str_block_id)
.map(
|BlockIdInput { block_id }|
matches!(block_id,
BlockId::Number(generated_block_number) if generated_block_number == expected_block_number)
).unwrap_or(false);
assert_eq!(should_be_correct, is_correct);
}
fn assert_block_id_block_hash_correctness(
should_be_correct: bool,
expected_block_hash: &str,
json_str_block_id: &str,
) {
let is_correct =
serde_json::from_str::<BlockIdInput>(json_str_block_id)
.map(|BlockIdInput { block_id }| matches!(block_id, BlockId::Hash(generated_block_hash) if generated_block_hash == felt_from_prefixed_hex(expected_block_hash).unwrap()))
.unwrap_or(false);
assert_eq!(should_be_correct, is_correct)
}
fn assert_transaction_hash_correctness(
should_be_correct: bool,
expected_transaction_hash: &str,
json_str_transaction_hash: &str,
) {
let is_correct = if let Ok(transaction_hash_input) =
serde_json::from_str::<super::TransactionHashInput>(json_str_transaction_hash)
{
transaction_hash_input.transaction_hash
== felt_from_prefixed_hex(expected_transaction_hash).unwrap()
} else {
false
};
assert_eq!(should_be_correct, is_correct);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/spec_modifier.rs | crates/starknet-devnet-server/src/api/spec_reader/spec_modifier.rs | use std::fs;
use serde::Deserialize;
use serde_json::Value;
use super::Spec;
/// Note: this structs is not all round solution for modifying the specification.
/// It has some limitations, if you need to modify the specification in a way that is not supported
/// Please use the remove_manually entry of the .yaml file
#[derive(Deserialize)]
pub struct SpecModifier {
clean: Vec<String>,
replace_property: Vec<ReplacePropertyData>,
add: Vec<AddPropertyData>,
remove_from_array: Vec<RemoveArrayElement>,
}
#[derive(Deserialize)]
struct ReplacePropertyData {
path: String,
new_name: String,
}
#[derive(Deserialize)]
struct AddPropertyData {
path: String,
new_entry: String,
// default value is false
#[serde(default)]
replace_mode: bool,
}
#[derive(Deserialize)]
struct RemoveArrayElement {
path: String,
index: usize,
}
fn rename_property(json_obj: &mut Value, path_parts: &[&str], new_name: &str) {
if path_parts.len() == 1 {
if let Some(obj) = json_obj.as_object_mut() {
if let Some(value) = obj.remove(path_parts[0]) {
obj.insert(new_name.to_string(), value);
}
}
} else if let Some(next_obj) = json_obj.get_mut(path_parts[0]) {
rename_property(next_obj, &path_parts[1..], new_name);
}
}
/// Deletes a property from a JSON object
fn delete_property(json_obj: &mut Value, path_parts: &[&str]) {
if path_parts.len() == 1 {
if let Some(obj) = json_obj.as_object_mut() {
obj.remove(path_parts[0]);
}
} else if let Some(next_obj) = json_obj.get_mut(path_parts[0]) {
delete_property(next_obj, &path_parts[1..]);
}
}
/// Adds a property to a JSON object.
///
/// The new property is specified in the form `"key/value"`.
/// The value is added as a string or number, depending on whether it can be parsed into a number.
///
/// - If `do_replace` is `true`, the value will be added only if the key already exists.
/// - If `do_replace` is `false`, the value will be added anyways.
///
/// # Arguments
///
/// - `json_obj`: A mutable reference to the JSON `Value` to modify.
/// - `path_parts`: A slice of strings representing the path within the JSON object where the
/// property should be added.
/// - `new_entry`: A string in the form `"key/value"` specifying the new property to add.
/// - `do_replace`: A boolean flag indicating whether to replace the value if the key already
/// exists.
fn add_property(json_obj: &mut Value, path_parts: &[&str], new_entry: &str, do_replace: bool) {
if path_parts.is_empty() {
if let Some(obj) = json_obj.as_object_mut() {
let new_entry_parts = new_entry.split('/').collect::<Vec<&str>>();
let value = new_entry_parts[1..].join("/");
let value = if let Ok(parsed_number) = value.parse::<u64>() {
serde_json::Value::Number(parsed_number.into())
} else {
serde_json::Value::String(value)
};
let key = new_entry_parts[0];
if do_replace {
if obj.contains_key(key) {
obj.insert(key.to_string(), value);
}
} else {
obj.insert(key.to_string(), value);
}
}
} else if let Some(next_obj) = json_obj.get_mut(path_parts[0]) {
add_property(next_obj, &path_parts[1..], new_entry, do_replace);
}
}
fn remove_array_element(json_obj: &mut Value, path_parts: &[&str], index: usize) {
if path_parts.is_empty() {
if let Some(arr) = json_obj.as_array_mut() {
arr.remove(index);
}
} else if let Some(next_obj) = json_obj.get_mut(path_parts[0]) {
remove_array_element(next_obj, &path_parts[1..], index);
}
}
impl SpecModifier {
pub fn load_from_path(path: &str) -> Self {
let yaml_str = fs::read_to_string(path).expect("Could not read YAML file");
let instructions: SpecModifier =
serde_yaml::from_str(&yaml_str).expect("Could not parse the YAML file");
instructions
}
pub fn generate_spec(&self, mut json_obj_spec: Value) -> Spec {
for path_to_clean in self.clean.iter() {
let path_parts = path_to_clean.split('/').collect::<Vec<&str>>();
delete_property(&mut json_obj_spec, &path_parts);
}
for path_to_replace in self.replace_property.iter() {
let path_parts = path_to_replace.path.split('/').collect::<Vec<&str>>();
rename_property(&mut json_obj_spec, &path_parts, &path_to_replace.new_name);
}
for entry_to_add in self.add.iter() {
let path_parts = entry_to_add.path.split('/').collect::<Vec<&str>>();
add_property(
&mut json_obj_spec,
&path_parts,
&entry_to_add.new_entry,
entry_to_add.replace_mode,
);
}
for array_element_to_remove in self.remove_from_array.iter() {
let path_parts = array_element_to_remove.path.split('/').collect::<Vec<&str>>();
remove_array_element(&mut json_obj_spec, &path_parts, array_element_to_remove.index);
}
// Serialize serde_json::Value to string first and then deserialize to object Spec,
// because if there is an error during deserialization, the error message will contain at
// which line number and column, the deserialization failed.
let json_spec_str = serde_json::to_string_pretty(&json_obj_spec)
.expect("could not serialize the spec to string");
// Parse the spec into a Spec struct
match serde_json::from_str(&json_spec_str) {
Ok(obj) => obj,
Err(e) => {
std::fs::write("failed_spec.json", json_spec_str).unwrap();
panic!("Could not parse the JSON-RPC spec: {e:?}");
}
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/mod.rs | crates/starknet-devnet-server/src/api/spec_reader/mod.rs | use std::collections::HashMap;
use std::ffi::OsStr;
use std::fs;
use serde::Deserialize;
use serde_json::{Map, Value};
use self::data_generator::generate_schema_value;
use self::spec_schemas::Schema;
mod data_generator;
mod spec_modifier;
mod spec_schemas;
#[derive(Deserialize)]
pub struct Spec {
methods: Vec<ApiMethod>,
components: Components,
}
#[derive(Deserialize)]
struct ApiMethod {
name: String,
params: Vec<Param>,
result: Option<Result>,
}
#[derive(Deserialize)]
struct Param {
name: String,
// TODO: improve generation logic to use this field
// #[serde(default)]
// required: bool,
schema: Schema,
}
#[derive(Deserialize)]
struct Result {
schema: Schema,
}
#[derive(Deserialize)]
struct Components {
schemas: HashMap<String, Schema>,
}
impl Spec {
fn load_from_dir(dir_path: &str) -> Vec<Self> {
let mut specs: Vec<Spec> = Vec::new();
let mut instructions = Option::None;
for path in fs::read_dir(dir_path).unwrap() {
let path = path.unwrap().path();
if let Some("yaml") = path.as_path().extension().and_then(OsStr::to_str) {
instructions = Some(spec_modifier::SpecModifier::load_from_path(
path.as_path().to_str().unwrap(),
));
break;
}
}
for path in fs::read_dir(dir_path).unwrap() {
let path = path.unwrap().path();
if let Some("yaml") = path.as_path().extension().and_then(OsStr::to_str) {
continue;
}
let spec = Self::load_from_path(path.as_path().to_str().unwrap(), &instructions);
specs.push(spec);
}
specs
}
fn load_from_path(
path: &str,
modify_spec_instructions: &Option<spec_modifier::SpecModifier>,
) -> Self {
let spec_str = fs::read_to_string(path).expect("Could not read the JSON-RPC spec file");
if let Some(instructions) = modify_spec_instructions {
// Remove some parts of the spec which were added due to some mistake
let json_obj_spec: serde_json::Value = serde_json::from_str(&spec_str)
.expect("Could not parse the JSON-RPC spec file to JSON object");
instructions.generate_spec(json_obj_spec)
} else {
let spec: Spec =
serde_json::from_str(&spec_str).expect("Could not parse the JSON-RPC spec");
spec
}
}
}
fn generate_combined_schema(specs: &Vec<Spec>) -> HashMap<String, Schema> {
let mut combined_schema = HashMap::<String, Schema>::new();
for spec in specs {
for (schema_name, schema) in &spec.components.schemas {
match schema.clone() {
Schema::Ref(reference) => {
// if reference to external file, then dont add it
let schema_parts = reference
.ref_field
.trim_start_matches("./")
.split("#/components/schemas/")
.filter(|entry| !entry.is_empty())
.collect::<Vec<&str>>();
if schema_parts.len() == 1 {
// then it is not reference to external file
// only references to external files are not added
combined_schema.insert(schema_name.clone(), schema.clone());
}
}
_ => {
combined_schema.insert(schema_name.clone(), schema.clone());
}
}
}
}
combined_schema
}
fn generate_json_rpc_request(
method: &ApiMethod,
schemas: &HashMap<String, Schema>,
) -> core::result::Result<serde_json::Value, String> {
let mut request = HashMap::new();
request.insert("jsonrpc", Value::String("2.0".to_string()));
request.insert("method", Value::String(method.name.clone()));
request.insert("id", Value::Number(serde_json::Number::from(1)));
// Add the parameters to the request
let mut params = Map::new();
for param in method.params.iter() {
let param_value = generate_schema_value(¶m.schema, schemas, 0)?;
params.insert(param.name.clone(), param_value);
}
if !params.is_empty() {
request.insert("params", Value::Object(params));
} else {
request.insert("params", Value::Array(vec![]));
}
serde_json::to_value(&request)
.map_err(|err| format!("Could not serialize the JSON-RPC request: {}", err))
}
fn generate_json_rpc_response(
response_schema: &Schema,
schemas: &HashMap<String, Schema>,
) -> core::result::Result<serde_json::Value, String> {
generate_schema_value(response_schema, schemas, 0)
}
mod tests {
use std::fs::File;
use serde::Deserialize;
use serde::de::DeserializeOwned;
use serde_json::Value;
use super::{ApiMethod, Spec, generate_combined_schema, generate_json_rpc_response};
use crate::api::RPC_SPEC_VERSION;
use crate::api::models::{
JsonRpcRequest, JsonRpcSubscriptionRequest, StarknetResponse, StarknetSpecRequest,
};
use crate::api::spec_reader::generate_json_rpc_request;
use crate::subscribe::{SubscriptionConfirmation, SubscriptionResponse};
#[test]
/// This test asserts that the spec files used in testing indeed match the expected version
fn rpc_spec_using_correct_version() {
let manifest_dir = env!("CARGO_MANIFEST_DIR");
let path_to_spec_dir = format!("{manifest_dir}/test_data/spec/{RPC_SPEC_VERSION}");
let spec_files = std::fs::read_dir(path_to_spec_dir).unwrap();
// traverse all json files in the rpc spec dir and assert they all have the expected version
for spec_file in
spec_files.filter(|f| f.as_ref().unwrap().path().extension().unwrap() == "json")
{
let spec_file_path = spec_file.unwrap().path();
let spec_file_path = spec_file_path.to_str().unwrap();
let spec_reader = std::fs::File::open(spec_file_path).unwrap();
let spec_content: serde_json::Value = serde_json::from_reader(spec_reader).unwrap();
match spec_content
.get("info")
.and_then(|info| info.get("version"))
.and_then(|ver| ver.as_str())
{
Some(RPC_SPEC_VERSION) => (),
other => panic!("Invalid version in {spec_file_path}: {other:?}"),
}
}
}
#[test]
fn test_spec_methods() {
let specs_folder = concat!(env!("CARGO_MANIFEST_DIR"), "/test_data/spec/");
let specs = Spec::load_from_dir(format!("{specs_folder}/{RPC_SPEC_VERSION}",).as_str());
let combined_schema = generate_combined_schema(&specs);
for i in 1..=1000 {
for spec in specs.iter() {
// Iterate over the methods in the spec
for method in spec.methods.iter() {
// Create a JSON-RPC request for each method
let request = generate_json_rpc_request(method, &combined_schema)
.unwrap_or_else(|e| {
panic!(
"i={i} Failed generating request for RPC method {}: {e}",
method.name
)
});
let response = method.result.as_ref().map(|result_schema| {
generate_json_rpc_response(&result_schema.schema, &combined_schema)
.unwrap_or_else(|e| {
panic!(
"i={i} Failed generating response for RPC method {}: {e}",
method.name
)
})
});
#[derive(Deserialize)]
#[serde(untagged)]
enum ApiOrWsRequest {
Api(Box<JsonRpcRequest>),
SubscribeWs(JsonRpcSubscriptionRequest),
WsNotification(Box<SubscriptionResponse>),
}
let sn_request =
deserialize_to_type_or_panic::<ApiOrWsRequest>(request, &method.name);
match sn_request {
ApiOrWsRequest::Api(json_rpc_request) => {
let response = response.unwrap();
let sn_response: StarknetResponse =
deserialize_to_type_or_panic(response, &method.name);
assert_api_request_and_response_are_related(
&json_rpc_request,
sn_response,
method,
);
}
ApiOrWsRequest::SubscribeWs(_json_rpc_subscription_request) => {
let response = response.unwrap();
deserialize_to_type_or_panic::<SubscriptionConfirmation>(
response,
&method.name,
);
}
ApiOrWsRequest::WsNotification(subscription_response) => {
match *subscription_response {
SubscriptionResponse::Confirmation { .. } => {
panic!("Unexpected data")
}
SubscriptionResponse::Notification(_) => {}
}
}
}
}
}
}
}
fn deserialize_to_type_or_panic<T: DeserializeOwned>(
json_value: Value,
method_name: &String,
) -> T {
let failed_file_name = if json_value.get("method").is_some() {
"failed_request.json"
} else {
"failed_response.json"
};
let deserialized = serde_json::from_value::<T>(json_value.clone());
if let Some(err) = deserialized.as_ref().err() {
serde_json::to_writer_pretty(File::create(failed_file_name).unwrap(), &json_value)
.unwrap();
panic!("{} method {} with {:?}.", failed_file_name, method_name, err);
}
deserialized.unwrap()
}
fn assert_api_request_and_response_are_related(
sn_request: &JsonRpcRequest,
sn_response: StarknetResponse,
method: &ApiMethod,
) {
match sn_request {
JsonRpcRequest::StarknetSpecRequest(req) => match req {
StarknetSpecRequest::BlockWithTransactionHashes(_)
| StarknetSpecRequest::BlockWithFullTransactions(_)
| StarknetSpecRequest::BlockWithReceipts(_) => {
assert!(matches!(
sn_response,
StarknetResponse::Block(_) | StarknetResponse::PreConfirmedBlock(_)
));
}
StarknetSpecRequest::TransactionReceiptByTransactionHash(_) => {
assert!(matches!(
sn_response,
StarknetResponse::TransactionReceiptByTransactionHash(_)
));
}
StarknetSpecRequest::ClassAtContractAddress(_)
| StarknetSpecRequest::ClassByHash(_) => {
assert!(matches!(sn_response, StarknetResponse::ContractClass(_)));
}
StarknetSpecRequest::BlockTransactionCount(_)
| StarknetSpecRequest::BlockNumber => {
assert!(matches!(
sn_response,
StarknetResponse::BlockTransactionCount(_)
| StarknetResponse::BlockNumber(_)
));
}
StarknetSpecRequest::Call(_) => {
assert!(matches!(sn_response, StarknetResponse::Call(_)))
}
StarknetSpecRequest::EstimateFee(_) => {
assert!(matches!(sn_response, StarknetResponse::EstimateFee(_)))
}
StarknetSpecRequest::BlockHashAndNumber => {
assert!(matches!(sn_response, StarknetResponse::BlockHashAndNumber(_)));
}
StarknetSpecRequest::EstimateMessageFee(_) => {
assert!(matches!(sn_response, StarknetResponse::EstimateMessageFee(_)));
}
StarknetSpecRequest::Events(_) => {
assert!(matches!(sn_response, StarknetResponse::Events(_)));
}
StarknetSpecRequest::SimulateTransactions(_) => {
assert!(matches!(sn_response, StarknetResponse::SimulateTransactions(_)));
}
StarknetSpecRequest::StateUpdate(_) => {
assert!(matches!(
sn_response,
StarknetResponse::StateUpdate(_)
| StarknetResponse::PreConfirmedStateUpdate(_)
));
}
StarknetSpecRequest::Syncing => {
assert!(matches!(sn_response, StarknetResponse::Syncing(_)));
}
StarknetSpecRequest::TransactionStatusByHash(_) => {
assert!(matches!(sn_response, StarknetResponse::TransactionStatusByHash(_)));
}
StarknetSpecRequest::AddDeclareTransaction(_) => {
assert!(matches!(sn_response, StarknetResponse::AddDeclareTransaction(_)));
}
StarknetSpecRequest::AddDeployAccountTransaction(_) => {
assert!(matches!(
sn_response,
StarknetResponse::AddDeployAccountTransaction(_)
));
}
StarknetSpecRequest::AddInvokeTransaction(_) => {
assert!(matches!(sn_response, StarknetResponse::TransactionHash(_)));
}
StarknetSpecRequest::SpecVersion => {
assert!(matches!(sn_response, StarknetResponse::String(_)));
}
StarknetSpecRequest::TransactionByHash(_)
| StarknetSpecRequest::TransactionByBlockAndIndex(_) => {
assert!(matches!(sn_response, StarknetResponse::Transaction(_)));
}
StarknetSpecRequest::ContractNonce(_)
| StarknetSpecRequest::ChainId
| StarknetSpecRequest::ClassHashAtContractAddress(_)
| StarknetSpecRequest::StorageAt(_) => {
assert!(matches!(sn_response, StarknetResponse::Felt(_)));
}
StarknetSpecRequest::TraceTransaction(_) => {
assert!(matches!(sn_response, StarknetResponse::TraceTransaction(_)));
}
StarknetSpecRequest::BlockTransactionTraces(_) => {
assert!(matches!(sn_response, StarknetResponse::BlockTransactionTraces(_)));
}
StarknetSpecRequest::MessagesStatusByL1Hash(_) => {
assert!(matches!(sn_response, StarknetResponse::MessagesStatusByL1Hash(_)));
}
StarknetSpecRequest::CompiledCasmByClassHash(_) => {
assert!(matches!(sn_response, StarknetResponse::CompiledCasm(_)));
}
StarknetSpecRequest::StorageProof(_) => {
panic!("Should never be matched, unused by Devnet")
}
},
_ => panic!(
"Devnet methods not asserted. This match case must not be reached, because this \
method covers starknet RPC method (starknet_.....) {:?} {}",
sn_request, method.name
),
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/data_generator.rs | crates/starknet-devnet-server/src/api/spec_reader/data_generator.rs | use std::collections::HashMap;
use rand::{Rng, SeedableRng};
use serde_json::{Map, Value};
use super::spec_schemas::all_of_schema::AllOf;
use super::spec_schemas::array_primitive::ArrayPrimitive;
use super::spec_schemas::integer_primitive::IntegerPrimitive;
use super::spec_schemas::object_primitive::ObjectPrimitive;
use super::spec_schemas::one_of_schema::OneOf;
use super::spec_schemas::ref_schema::Reference;
use super::spec_schemas::string_primitive::StringPrimitive;
use super::spec_schemas::tuple_schema::Tuple;
use super::spec_schemas::{Primitive, Schema};
const MAX_DEPTH: u8 = 5;
/// regex pattern for 1-10 characters
const DEFAULT_STRING_REGEX: &str = "^.{1,10}$";
pub trait Visitor {
fn do_for_boolean_primitive(&self) -> Result<serde_json::Value, String>;
fn do_for_string_primitive(
&self,
element: &StringPrimitive,
) -> Result<serde_json::Value, String>;
fn do_for_integer_primitive(
&self,
element: &IntegerPrimitive,
) -> Result<serde_json::Value, String>;
fn do_for_array_primitive(&self, element: &ArrayPrimitive)
-> Result<serde_json::Value, String>;
fn do_for_ref(&self, element: &Reference) -> Result<serde_json::Value, String>;
fn do_for_one_of(&self, element: &OneOf) -> Result<serde_json::Value, String>;
fn do_for_all_of(&self, element: &AllOf) -> Result<serde_json::Value, String>;
fn do_for_object_primitive(
&self,
element: &ObjectPrimitive,
) -> Result<serde_json::Value, String>;
fn do_for_tuple(&self, element: &Tuple) -> Result<serde_json::Value, String>;
}
pub trait Acceptor {
fn accept(&self, visitor: &impl Visitor) -> Result<serde_json::Value, String>;
}
pub struct RandDataGenerator<'a> {
schemas: &'a HashMap<String, Schema>,
depth: u8,
}
impl<'a> RandDataGenerator<'a> {
pub fn new(schemas: &'a HashMap<String, Schema>, depth: u8) -> Self {
Self { schemas, depth }
}
}
impl Visitor for RandDataGenerator<'_> {
fn do_for_boolean_primitive(&self) -> Result<serde_json::Value, String> {
Ok(serde_json::Value::Bool(rand::rng().random_bool(0.5)))
}
fn do_for_string_primitive(
&self,
element: &StringPrimitive,
) -> Result<serde_json::Value, String> {
if let Some(enums) = element.possible_enums.clone() {
let random_number = rand::rng().random_range(0..enums.len());
return Ok(serde_json::Value::String(enums[random_number].clone()));
}
// If pattern is not set, then generate a string from the default pattern
let regex_pattern: String = element
.pattern
.as_deref()
.unwrap_or(DEFAULT_STRING_REGEX)
.chars()
.filter(|c| *c != '^' && *c != '$')
.collect();
let seed = rand::rng().random();
let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(seed);
let rgx = rand_regex::Regex::compile(regex_pattern.as_str(), 100).unwrap();
let random_string =
(&mut rng).sample_iter(&rgx).take(1).collect::<Vec<String>>().first().unwrap().clone();
Ok(serde_json::Value::String(random_string))
}
fn do_for_integer_primitive(
&self,
element: &IntegerPrimitive,
) -> Result<serde_json::Value, String> {
let num = rand::rng()
.random_range(element.minimum.unwrap_or_default()..element.maximum.unwrap_or(i32::MAX));
Ok(serde_json::Value::Number(serde_json::Number::from(num)))
}
fn do_for_array_primitive(
&self,
element: &ArrayPrimitive,
) -> Result<serde_json::Value, String> {
let mut array = vec![];
if self.depth >= MAX_DEPTH {
return Ok(serde_json::Value::Array(array));
}
let min_items = element.min_items.unwrap_or(1);
let max_items = element.max_items.unwrap_or(3);
let number_of_elements = rand::rng().random_range(min_items..=max_items);
for _ in 0..number_of_elements {
let generated_value =
generate_schema_value(element.items.as_ref(), self.schemas, self.depth + 1)?;
if !generated_value.is_null() {
array.push(generated_value);
}
}
Ok(serde_json::Value::Array(array))
}
fn do_for_ref(&self, element: &Reference) -> Result<serde_json::Value, String> {
let schema_name = element
.ref_field
.trim_start_matches("./")
.split("#/components/schemas/")
.filter(|entry| !entry.is_empty())
.last()
.unwrap_or_default();
let schema = self
.schemas
.get(schema_name)
.ok_or(format!("Missing schema in components {}", schema_name))?;
generate_schema_value(schema, self.schemas, self.depth)
}
fn do_for_one_of(&self, element: &OneOf) -> Result<serde_json::Value, String> {
let idx = rand::rng().random_range(0..element.one_of.len());
let schema =
element.one_of.get(idx).ok_or("OneOf schema doesn't have entry".to_string())?;
generate_schema_value(schema, self.schemas, self.depth)
}
fn do_for_all_of(&self, element: &AllOf) -> Result<serde_json::Value, String> {
let mut accumulated_json_value = Map::new();
for one in element.all_of.iter() {
let generated_value = generate_schema_value(one, self.schemas, self.depth)?;
if !generated_value.is_null() {
let single_value = generated_value
.as_object()
.ok_or(format!(
"Expected to be an object: {generated_value:?}. AllOf element: {element:?}"
))?
.clone();
accumulated_json_value.extend(single_value);
}
}
if accumulated_json_value.is_empty() {
Ok(Value::Null)
} else {
Ok(serde_json::Value::Object(accumulated_json_value))
}
}
fn do_for_object_primitive(
&self,
element: &ObjectPrimitive,
) -> Result<serde_json::Value, String> {
if self.depth >= MAX_DEPTH {
return Ok(Value::Null);
}
let mut accumulated_json_value = Map::new();
// Collect all field names as references
let all_fields: Vec<&String> = element.properties.keys().collect();
// if there are no required json entry, then all propertries are required
let required_fields: Vec<&String> = if let Some(required) = &element.required {
required.iter().collect()
} else {
all_fields.clone()
};
// Determine optional fields by removing required fields from all fields
let mut optional_fields: Vec<&String> =
all_fields.iter().filter(|field| !required_fields.contains(field)).cloned().collect();
// if there are no optional fields then all fields have to be included
let fields_to_include = if optional_fields.is_empty() {
required_fields
} else {
// decide the number of optional fields to remove
let mut optional_fields_left_to_remove =
rand::rng().random_range(0..=optional_fields.len());
// remove the optional fields 1 by 1
while optional_fields_left_to_remove > 0 {
optional_fields_left_to_remove -= 1;
let idx_to_remove = rand::rng().random_range(0..optional_fields.len());
optional_fields.swap_remove(idx_to_remove);
}
// combine required and optional fields that will be part of the json object
[required_fields.as_slice(), optional_fields.as_slice()].concat()
};
for (key, inner_schema) in
element.properties.iter().filter(|(k, _)| fields_to_include.contains(k))
{
let generated_value =
generate_schema_value(inner_schema, self.schemas, self.depth + 1)?;
// this means that it reached max depth, but one last value must be generated,
// because it the object will be generated without this property and further
// deserialization will fail with missing field
if generated_value.is_null() {
let generated_value =
generate_schema_value(inner_schema, self.schemas, self.depth)?;
accumulated_json_value.insert(key.to_string(), generated_value);
} else {
accumulated_json_value.insert(key.to_string(), generated_value);
}
}
if accumulated_json_value.is_empty() {
Ok(Value::Null)
} else {
Ok(Value::Object(accumulated_json_value))
}
}
fn do_for_tuple(&self, element: &Tuple) -> Result<serde_json::Value, String> {
let mut array = vec![];
if self.depth >= MAX_DEPTH {
return Ok(serde_json::Value::Null);
}
for variant in element.variants.iter() {
let generated_value = generate_schema_value(variant, self.schemas, self.depth + 1)?;
if generated_value.is_null() {
let generated_value = generate_schema_value(variant, self.schemas, self.depth)?;
array.push(generated_value);
} else {
array.push(generated_value);
}
}
Ok(serde_json::Value::Array(array))
}
}
pub fn generate_schema_value(
schema: &Schema,
schemas: &HashMap<String, Schema>,
depth: u8,
) -> core::result::Result<Value, String> {
let generator = RandDataGenerator::new(schemas, depth);
match schema {
Schema::Ref(schema_ref) => schema_ref.accept(&generator),
Schema::OneOf(one) => one.accept(&generator),
Schema::AllOf(all) => all.accept(&generator),
Schema::Primitive(Primitive::Integer(integer_primitive)) => {
integer_primitive.accept(&generator)
}
Schema::Primitive(Primitive::Number(number_primitive)) => {
number_primitive.accept(&generator)
}
Schema::Primitive(Primitive::String(string_primitive)) => {
string_primitive.accept(&generator)
}
Schema::Primitive(Primitive::Array(array)) => array.accept(&generator),
Schema::Primitive(Primitive::Boolean(boolean)) => boolean.accept(&generator),
Schema::Primitive(Primitive::Object(obj)) => obj.accept(&generator),
Schema::Tuple(tuple) => tuple.accept(&generator),
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/array_primitive.rs | crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/array_primitive.rs | use serde::{Deserialize, Serialize};
use super::{Common, Schema};
use crate::api::spec_reader::data_generator::{Acceptor, Visitor};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ArrayPrimitive {
#[serde(flatten)]
pub common: Common,
pub items: Box<Schema>,
pub min_items: Option<u64>,
pub max_items: Option<u64>,
}
impl Acceptor for ArrayPrimitive {
fn accept(&self, visitor: &impl Visitor) -> Result<serde_json::Value, String> {
visitor.do_for_array_primitive(self)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/string_primitive.rs | crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/string_primitive.rs | use serde::{Deserialize, Serialize};
use super::Common;
use crate::api::spec_reader::data_generator::{Acceptor, Visitor};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct StringPrimitive {
#[serde(flatten)]
pub common: Common,
#[serde(rename = "$comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
#[serde(rename = "enum")]
pub possible_enums: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pattern: Option<String>,
}
impl Acceptor for StringPrimitive {
fn accept(&self, visitor: &impl Visitor) -> Result<serde_json::Value, String> {
visitor.do_for_string_primitive(self)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/integer_primitive.rs | crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/integer_primitive.rs | use serde::{Deserialize, Serialize};
use super::Common;
use crate::api::spec_reader::data_generator::{Acceptor, Visitor};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct IntegerPrimitive {
#[serde(flatten)]
pub common: Common,
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum: Option<i32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum: Option<i32>,
}
impl Acceptor for IntegerPrimitive {
fn accept(&self, visitor: &impl Visitor) -> Result<serde_json::Value, String> {
visitor.do_for_integer_primitive(self)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/object_primitive.rs | crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/object_primitive.rs | use std::collections::HashMap;
use serde::{Deserialize, Serialize};
use super::{Common, Schema};
use crate::api::spec_reader::data_generator::{Acceptor, Visitor};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ObjectPrimitive {
#[serde(flatten)]
pub common: Common,
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<String>,
pub properties: HashMap<String, Schema>,
#[serde(skip_serializing_if = "Option::is_none")]
pub required: Option<Vec<String>>,
}
impl Acceptor for ObjectPrimitive {
fn accept(&self, visitor: &impl Visitor) -> Result<serde_json::Value, String> {
visitor.do_for_object_primitive(self)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/boolean_primitive.rs | crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/boolean_primitive.rs | use serde::{Deserialize, Serialize};
use super::Common;
use crate::api::spec_reader::data_generator::{Acceptor, Visitor};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct BooleanPrimitive {
#[serde(flatten)]
pub common: Common,
#[serde(skip)]
pub generated_value: Option<bool>,
}
impl Acceptor for BooleanPrimitive {
fn accept(&self, visitor: &impl Visitor) -> Result<serde_json::Value, String> {
visitor.do_for_boolean_primitive()
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/mod.rs | crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/mod.rs | use serde::{Deserialize, Serialize};
use tuple_schema::Tuple;
use self::all_of_schema::AllOf;
use self::array_primitive::ArrayPrimitive;
use self::boolean_primitive::BooleanPrimitive;
use self::integer_primitive::IntegerPrimitive;
use self::object_primitive::ObjectPrimitive;
use self::one_of_schema::OneOf;
use self::ref_schema::Reference;
use self::string_primitive::StringPrimitive;
pub mod all_of_schema;
pub mod array_primitive;
pub mod boolean_primitive;
pub mod integer_primitive;
pub mod object_primitive;
pub mod one_of_schema;
pub mod ref_schema;
pub mod string_primitive;
pub mod tuple_schema;
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Common {
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_properties: Option<bool>,
#[serde(rename = "type")]
pub t: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub not: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(tag = "type", rename_all = "lowercase")]
pub enum Primitive {
Array(ArrayPrimitive),
Boolean(BooleanPrimitive),
Integer(IntegerPrimitive),
Number(IntegerPrimitive),
Object(ObjectPrimitive),
String(StringPrimitive),
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(untagged)]
pub enum Schema {
Ref(Reference),
OneOf(OneOf),
AllOf(AllOf),
Primitive(Primitive),
Tuple(Tuple),
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/ref_schema.rs | crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/ref_schema.rs | use serde::{Deserialize, Serialize};
use super::Common;
use crate::api::spec_reader::data_generator::{Acceptor, Visitor};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Reference {
#[serde(rename = "$comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<String>,
#[serde(rename = "$ref")]
pub ref_field: String,
#[serde(flatten)]
pub common: Common,
}
impl Acceptor for Reference {
fn accept(&self, visitor: &impl Visitor) -> Result<serde_json::Value, String> {
visitor.do_for_ref(self)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/one_of_schema.rs | crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/one_of_schema.rs | use serde::{Deserialize, Serialize};
use super::{Common, Schema};
use crate::api::spec_reader::data_generator::{Acceptor, Visitor};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct OneOf {
#[serde(flatten)]
pub common: Common,
pub one_of: Vec<Schema>,
}
impl Acceptor for OneOf {
fn accept(&self, visitor: &impl Visitor) -> Result<serde_json::Value, String> {
visitor.do_for_one_of(self)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/tuple_schema.rs | crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/tuple_schema.rs | use serde::{Deserialize, Serialize};
use super::{Common, Schema};
use crate::api::spec_reader::data_generator::{Acceptor, Visitor};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Tuple {
#[serde(flatten)]
pub common: Common,
#[serde(rename = "tuple")]
pub variants: Vec<Schema>,
}
impl Acceptor for Tuple {
fn accept(&self, visitor: &impl Visitor) -> Result<serde_json::Value, String> {
visitor.do_for_tuple(self)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/all_of_schema.rs | crates/starknet-devnet-server/src/api/spec_reader/spec_schemas/all_of_schema.rs | use serde::{Deserialize, Serialize};
use super::{Common, Schema};
use crate::api::spec_reader::data_generator::{Acceptor, Visitor};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct AllOf {
#[serde(flatten)]
pub common: Common,
pub all_of: Vec<Schema>,
}
impl Acceptor for AllOf {
fn accept(&self, visitor: &impl Visitor) -> Result<serde_json::Value, String> {
visitor.do_for_all_of(self)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/rpc_core/response.rs | crates/starknet-devnet-server/src/rpc_core/response.rs | use serde::{Deserialize, Serialize};
use crate::rpc_core::error::RpcError;
use crate::rpc_core::request::{Id, Version};
/// Response of a _single_ rpc call
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RpcResponse {
// JSON RPC version
jsonrpc: Version,
#[serde(skip_serializing_if = "Option::is_none")]
id: Option<Id>,
#[serde(flatten)]
pub(crate) result: ResponseResult,
}
impl RpcResponse {
pub fn new(id: Id, content: impl Into<ResponseResult>) -> Self {
RpcResponse { jsonrpc: Version::V2, id: Some(id), result: content.into() }
}
pub fn invalid_request(id: Id) -> Self {
Self::new(id, RpcError::invalid_request())
}
pub fn from_rpc_error(e: RpcError, id: Id) -> Self {
Self { jsonrpc: Version::V2, id: Some(id), result: ResponseResult::Error(e) }
}
}
/// Represents the result of a call either success or error
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub enum ResponseResult {
#[serde(rename = "result")]
Success(serde_json::Value),
#[serde(rename = "error")]
Error(RpcError),
}
impl ResponseResult {
pub fn error(error: RpcError) -> Self {
ResponseResult::Error(error)
}
}
impl From<RpcError> for ResponseResult {
fn from(err: RpcError) -> Self {
ResponseResult::error(err)
}
}
/// Synchronous response
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[serde(deny_unknown_fields)]
#[serde(untagged)]
pub enum Response {
/// single json rpc response
Single(RpcResponse),
/// batch of several responses
Batch(Vec<RpcResponse>),
}
impl Response {
/// Creates new [Response] with the given [Error]
pub fn error(error: RpcError) -> Self {
RpcResponse::new(Id::Null, ResponseResult::Error(error)).into()
}
}
impl From<RpcError> for Response {
fn from(err: RpcError) -> Self {
Response::error(err)
}
}
impl From<RpcResponse> for Response {
fn from(resp: RpcResponse) -> Self {
Response::Single(resp)
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/rpc_core/error.rs | crates/starknet-devnet-server/src/rpc_core/error.rs | //! JSON-RPC error bindings
use std::borrow::Cow;
use std::fmt;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use serde_json::json;
/// Represents a JSON-RPC error
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RpcError {
pub code: ErrorCode,
/// error message
pub message: Cow<'static, str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<serde_json::Value>,
}
impl RpcError {
/// New [Error] with the given [ErrorCode]
pub const fn new(code: ErrorCode) -> Self {
RpcError { message: Cow::Borrowed(code.message()), code, data: None }
}
/// Creates a new `ParseError`
pub fn parse_error<R>(reason: R) -> Self
where
R: Into<String>,
{
RpcError {
code: ErrorCode::ParseError,
message: Cow::Borrowed(ErrorCode::ParseError.message()),
data: Some(json!({ "reason": reason.into() })),
}
}
/// Creates a new `MethodNotFound`
pub const fn method_not_found() -> Self {
Self::new(ErrorCode::MethodNotFound)
}
/// Creates a new `InvalidRequest`
pub const fn invalid_request() -> Self {
Self::new(ErrorCode::InvalidRequest)
}
// Creates a new `InvalidRequest` with a message
pub fn invalid_request_with_reason<R>(reason: R) -> Self
where
R: Into<String>,
{
RpcError {
code: ErrorCode::InvalidRequest,
message: Cow::Borrowed(ErrorCode::InvalidRequest.message()),
data: Some(json!({ "reason": reason.into() })),
}
}
/// Creates a new `InternalError`
pub const fn internal_error() -> Self {
Self::new(ErrorCode::InternalError)
}
/// Creates a new `InvalidParams`
pub fn invalid_params<M>(message: M) -> Self
where
M: Into<String>,
{
RpcError { code: ErrorCode::InvalidParams, message: message.into().into(), data: None }
}
/// Creates a new `InternalError` with a message
pub fn internal_error_with<M>(message: M) -> Self
where
M: Into<String>,
{
RpcError { code: ErrorCode::InternalError, message: message.into().into(), data: None }
}
/// Creates a new rpc error for when a transaction was rejected
pub fn transaction_rejected<M>(message: M) -> Self
where
M: Into<String>,
{
RpcError {
code: ErrorCode::TransactionRejected,
message: message.into().into(),
data: None,
}
}
}
impl fmt::Display for RpcError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}: {}", self.code.message(), self.message)
}
}
/// List of JSON-RPC error codes
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ErrorCode {
/// Server received Invalid JSON.
/// server side error while parsing JSON
ParseError,
/// send invalid request object.
InvalidRequest,
/// method does not exist or valid
MethodNotFound,
/// invalid method parameter.
InvalidParams,
/// internal call error
InternalError,
/// Failed to send transaction, See also <https://github.com/MetaMask/eth-rpc-errors/blob/main/src/error-constants.ts>
TransactionRejected,
/// Custom geth error code, <https://github.com/vapory-legacy/wiki/blob/master/JSON-RPC-Error-Codes-Improvement-Proposal.md>
ExecutionError,
/// method is forbidden for execution
MethodForbidden,
/// Used for server specific errors.
ServerError(i64),
}
impl ErrorCode {
/// Returns the error code as `i64`
pub fn code(&self) -> i64 {
match *self {
ErrorCode::ParseError => -32700,
ErrorCode::InvalidRequest => -32600,
ErrorCode::MethodNotFound => -32601,
ErrorCode::InvalidParams => -32602,
ErrorCode::InternalError => -32603,
ErrorCode::MethodForbidden => -32604,
ErrorCode::TransactionRejected => -32003,
ErrorCode::ExecutionError => 3,
ErrorCode::ServerError(c) => c,
}
}
/// Returns the message associated with the error
pub const fn message(&self) -> &'static str {
match *self {
ErrorCode::ParseError => "Parse error",
ErrorCode::InvalidRequest => "Invalid request",
ErrorCode::MethodNotFound => "Method not found",
ErrorCode::InvalidParams => "Invalid params",
ErrorCode::InternalError => "Internal error",
ErrorCode::TransactionRejected => "Transaction rejected",
ErrorCode::ServerError(_) => "Server error",
ErrorCode::ExecutionError => "Execution error",
ErrorCode::MethodForbidden => "Method forbidden",
}
}
}
impl Serialize for ErrorCode {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_i64(self.code())
}
}
impl<'a> Deserialize<'a> for ErrorCode {
fn deserialize<D>(deserializer: D) -> Result<ErrorCode, D::Error>
where
D: Deserializer<'a>,
{
i64::deserialize(deserializer).map(Into::into)
}
}
impl From<i64> for ErrorCode {
fn from(code: i64) -> Self {
match code {
-32700 => ErrorCode::ParseError,
-32600 => ErrorCode::InvalidRequest,
-32601 => ErrorCode::MethodNotFound,
-32602 => ErrorCode::InvalidParams,
-32603 => ErrorCode::InternalError,
-32604 => ErrorCode::MethodForbidden,
-32003 => ErrorCode::TransactionRejected,
3 => ErrorCode::ExecutionError,
_ => ErrorCode::ServerError(code),
}
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/rpc_core/mod.rs | crates/starknet-devnet-server/src/rpc_core/mod.rs | /// JSON-RPC request bindings
pub mod request;
/// JSON-RPC response bindings
pub mod response;
/// JSON-RPC error bindings
pub mod error;
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet-server/src/rpc_core/request.rs | crates/starknet-devnet-server/src/rpc_core/request.rs | use std::fmt;
use serde::{Deserialize, Serialize};
use starknet_types::messaging::MessageToL2;
use crate::error::Error;
/// A JSON-RPC request object, a method call
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RpcMethodCall {
/// The version of the protocol
pub jsonrpc: Version,
/// The name of the method to execute
pub method: String,
/// An array or object containing the parameters to be passed to the function.
#[serde(default = "no_params")]
pub params: RequestParams,
/// The identifier for this request issued by the client,
/// An [Id] must be a String, null or a number.
/// If missing it's considered a notification in [Version::V2]
pub id: Id,
}
impl RpcMethodCall {
pub fn id(&self) -> Id {
self.id.clone()
}
}
impl TryFrom<MessageToL2> for RpcMethodCall {
type Error = Error;
fn try_from(message: MessageToL2) -> Result<Self, Self::Error> {
(&message).try_into()
}
}
impl TryFrom<&MessageToL2> for RpcMethodCall {
type Error = Error;
fn try_from(message: &MessageToL2) -> Result<Self, Self::Error> {
let message_serialized =
serde_json::to_value(message).map_err(|e| Error::ConversionError(e.to_string()))?;
let params = message_serialized
.as_object()
.ok_or(Error::ConversionError("Message not convertible to JSON object".into()))?;
Ok(Self {
jsonrpc: Version::V2,
method: "devnet_postmanSendMessageToL2".into(),
params: RequestParams::Object(params.clone()),
id: Id::Number(0),
})
}
}
/// Represents a JSON-RPC request which is considered a notification (missing [Id] optional
/// [Version])
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RpcNotification {
pub jsonrpc: Option<Version>,
pub method: String,
#[serde(default = "no_params")]
pub params: RequestParams,
}
/// Representation of a single JSON-RPC call
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RpcCall {
/// the RPC method to invoke
MethodCall(RpcMethodCall),
/// A notification (no [Id] provided)
Notification(RpcNotification),
/// Invalid call
Invalid {
/// id or [Id::Null]
#[serde(default = "null_id")]
id: Id,
},
}
/// Represents a JSON-RPC request.
#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
#[serde(deny_unknown_fields)]
#[serde(untagged)]
pub enum Request {
/// single json rpc request [RpcCall]
Single(RpcCall),
/// batch of several requests
Batch(Vec<RpcCall>),
}
/// Request parameters
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged, deny_unknown_fields)]
pub enum RequestParams {
/// no parameters provided
None,
/// An array of JSON values
Array(Vec<serde_json::Value>),
/// a map of JSON values
Object(serde_json::Map<String, serde_json::Value>),
}
impl From<RequestParams> for serde_json::Value {
fn from(params: RequestParams) -> Self {
match params {
RequestParams::None => serde_json::Value::Null,
RequestParams::Array(arr) => arr.into(),
RequestParams::Object(obj) => obj.into(),
}
}
}
fn no_params() -> RequestParams {
RequestParams::None
}
/// Represents the version of the RPC protocol
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub enum Version {
#[serde(rename = "2.0")]
V2,
#[serde(rename = "1.0")]
V1,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Id {
String(String),
Number(i64),
Null,
}
impl fmt::Display for Id {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Id::String(s) => s.fmt(f),
Id::Number(n) => n.fmt(f),
Id::Null => f.write_str("null"),
}
}
}
fn null_id() -> Id {
Id::Null
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn can_serialize_batch() {
let batch = Request::Batch(vec![
RpcCall::MethodCall(RpcMethodCall {
jsonrpc: Version::V2,
method: "eth_method".to_owned(),
params: RequestParams::Array(vec![
serde_json::Value::from(999),
serde_json::Value::from(1337),
]),
id: Id::Number(1),
}),
RpcCall::Notification(RpcNotification {
jsonrpc: Some(Version::V2),
method: "eth_method".to_owned(),
params: RequestParams::Array(vec![serde_json::Value::from(999)]),
}),
]);
let obj = serde_json::to_string(&batch).unwrap();
assert_eq!(
obj,
r#"[{"jsonrpc":"2.0","method":"eth_method","params":[999,1337],"id":1},{"jsonrpc":"2.0","method":"eth_method","params":[999]}]"#
);
}
#[test]
fn can_deserialize_batch() {
let s = r#"[{}, {"jsonrpc": "2.0", "method": "eth_call", "params": [1337,420], "id": 1},{"jsonrpc": "2.0", "method": "notify", "params": [999]}]"#;
let obj: Request = serde_json::from_str(s).unwrap();
assert_eq!(
obj,
Request::Batch(vec![
RpcCall::Invalid { id: Id::Null },
RpcCall::MethodCall(RpcMethodCall {
jsonrpc: Version::V2,
method: "eth_call".to_owned(),
params: RequestParams::Array(vec![
serde_json::Value::from(1337),
serde_json::Value::from(420)
]),
id: Id::Number(1)
}),
RpcCall::Notification(RpcNotification {
jsonrpc: Some(Version::V2),
method: "notify".to_owned(),
params: RequestParams::Array(vec![serde_json::Value::from(999)])
})
])
)
}
#[test]
fn can_serialize_method() {
let m = RpcMethodCall {
jsonrpc: Version::V2,
method: "eth_method".to_owned(),
params: RequestParams::Array(vec![
serde_json::Value::from(999),
serde_json::Value::from(1337),
]),
id: Id::Number(1),
};
let obj = serde_json::to_string(&m).unwrap();
assert_eq!(obj, r#"{"jsonrpc":"2.0","method":"eth_method","params":[999,1337],"id":1}"#);
}
#[test]
fn can_serialize_call_notification() {
let n = RpcCall::Notification(RpcNotification {
jsonrpc: Some(Version::V2),
method: "eth_method".to_owned(),
params: RequestParams::Array(vec![serde_json::Value::from(999)]),
});
let obj = serde_json::to_string(&n).unwrap();
assert_eq!(obj, r#"{"jsonrpc":"2.0","method":"eth_method","params":[999]}"#);
}
#[test]
fn can_serialize_notification() {
let n = RpcNotification {
jsonrpc: Some(Version::V2),
method: "eth_method".to_owned(),
params: RequestParams::Array(vec![
serde_json::Value::from(999),
serde_json::Value::from(1337),
]),
};
let obj = serde_json::to_string(&n).unwrap();
assert_eq!(obj, r#"{"jsonrpc":"2.0","method":"eth_method","params":[999,1337]}"#);
}
#[test]
fn can_deserialize_notification() {
let s = r#"{"jsonrpc": "2.0", "method": "eth_method", "params": [999,1337]}"#;
let obj: RpcNotification = serde_json::from_str(s).unwrap();
assert_eq!(
obj,
RpcNotification {
jsonrpc: Some(Version::V2),
method: "eth_method".to_owned(),
params: RequestParams::Array(vec![
serde_json::Value::from(999),
serde_json::Value::from(1337)
])
}
);
let s = r#"{"jsonrpc": "2.0", "method": "foobar"}"#;
let obj: RpcNotification = serde_json::from_str(s).unwrap();
assert_eq!(
obj,
RpcNotification {
jsonrpc: Some(Version::V2),
method: "foobar".to_owned(),
params: RequestParams::None,
}
);
let s = r#"{"jsonrpc": "2.0", "method": "eth_method", "params": [999,1337], "id": 1}"#;
let obj: Result<RpcNotification, _> = serde_json::from_str(s);
assert!(obj.is_err());
}
#[test]
fn can_deserialize_call() {
let s = r#"{"jsonrpc": "2.0", "method": "eth_method", "params": [999]}"#;
let obj: RpcCall = serde_json::from_str(s).unwrap();
assert_eq!(
obj,
RpcCall::Notification(RpcNotification {
jsonrpc: Some(Version::V2),
method: "eth_method".to_owned(),
params: RequestParams::Array(vec![serde_json::Value::from(999)])
})
);
let s = r#"{"jsonrpc": "2.0", "method": "eth_method", "params": [999], "id": 1}"#;
let obj: RpcCall = serde_json::from_str(s).unwrap();
assert_eq!(
obj,
RpcCall::MethodCall(RpcMethodCall {
jsonrpc: Version::V2,
method: "eth_method".to_owned(),
params: RequestParams::Array(vec![serde_json::Value::from(999)]),
id: Id::Number(1)
})
);
let s = r#"{"jsonrpc": "2.0", "method": "eth_method", "params": [], "id": 1}"#;
let obj: RpcCall = serde_json::from_str(s).unwrap();
assert_eq!(
obj,
RpcCall::MethodCall(RpcMethodCall {
jsonrpc: Version::V2,
method: "eth_method".to_owned(),
params: RequestParams::Array(vec![]),
id: Id::Number(1)
})
);
let s = r#"{"jsonrpc": "2.0", "method": "eth_method", "params": null, "id": 1}"#;
let obj: RpcCall = serde_json::from_str(s).unwrap();
assert_eq!(
obj,
RpcCall::MethodCall(RpcMethodCall {
jsonrpc: Version::V2,
method: "eth_method".to_owned(),
params: RequestParams::None,
id: Id::Number(1)
})
);
let s = r#"{"jsonrpc": "2.0", "method": "eth_method", "id": 1}"#;
let obj: RpcCall = serde_json::from_str(s).unwrap();
assert_eq!(
obj,
RpcCall::MethodCall(RpcMethodCall {
jsonrpc: Version::V2,
method: "eth_method".to_owned(),
params: RequestParams::None,
id: Id::Number(1)
})
);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet/src/ip_addr_wrapper.rs | crates/starknet-devnet/src/ip_addr_wrapper.rs | use std::fmt::Display;
use std::net::{AddrParseError, IpAddr, Ipv4Addr};
use std::str::FromStr;
#[derive(Debug, Clone)]
#[cfg_attr(test, derive(PartialEq, Eq))]
pub(crate) struct IpAddrWrapper {
pub(crate) inner: IpAddr,
}
impl FromStr for IpAddrWrapper {
type Err = AddrParseError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match s {
"localhost" => Ok(IpAddrWrapper::LOCALHOST),
other => Ok(IpAddrWrapper { inner: IpAddr::V4(Ipv4Addr::from_str(other)?) }),
}
}
}
impl Display for IpAddrWrapper {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.inner)
}
}
impl Default for IpAddrWrapper {
fn default() -> Self {
Self::LOCALHOST
}
}
impl IpAddrWrapper {
pub(crate) const LOCALHOST: Self = IpAddrWrapper { inner: IpAddr::V4(Ipv4Addr::LOCALHOST) };
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet/src/initial_balance_wrapper.rs | crates/starknet-devnet/src/initial_balance_wrapper.rs | use std::fmt::Display;
use std::str::FromStr;
use starknet_core::constants::DEVNET_DEFAULT_INITIAL_BALANCE;
use starknet_types::rpc::state::Balance;
#[derive(Debug, Clone)]
pub(crate) struct InitialBalanceWrapper(pub Balance);
impl FromStr for InitialBalanceWrapper {
type Err = anyhow::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let balance = Balance::from_str(s)?;
Ok(Self(balance))
}
}
impl Display for InitialBalanceWrapper {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.0)
}
}
impl Default for InitialBalanceWrapper {
fn default() -> Self {
Self(Balance::from(DEVNET_DEFAULT_INITIAL_BALANCE))
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet/src/cli.rs | crates/starknet-devnet/src/cli.rs | use std::num::NonZeroU128;
use clap::Parser;
use server::ServerConfig;
use server::api::models::JsonRpcRequest;
use server::restrictive_mode::DEFAULT_RESTRICTED_JSON_RPC_METHODS;
use starknet_core::constants::{
ARGENT_CONTRACT_VERSION, ARGENT_MULTISIG_CONTRACT_VERSION, DEVNET_DEFAULT_L1_DATA_GAS_PRICE,
DEVNET_DEFAULT_L1_GAS_PRICE, DEVNET_DEFAULT_L2_GAS_PRICE, DEVNET_DEFAULT_PORT,
DEVNET_DEFAULT_TIMEOUT, DEVNET_DEFAULT_TOTAL_ACCOUNTS, MAXIMUM_CONTRACT_BYTECODE_SIZE,
MAXIMUM_CONTRACT_CLASS_SIZE, MAXIMUM_SIERRA_LENGTH, chargeable_account_initial_balance,
};
use starknet_core::contract_class_choice::{AccountClassWrapper, AccountContractClassChoice};
use starknet_core::random_number_generator::generate_u32_random_number;
use starknet_core::starknet::starknet_config::{
BlockGenerationOn, ClassSizeConfig, DumpOn, ForkConfig, StarknetConfig, StateArchiveCapacity,
};
use starknet_types::chain_id::ChainId;
use starknet_types::num_bigint::BigUint;
use tracing_subscriber::EnvFilter;
use crate::initial_balance_wrapper::InitialBalanceWrapper;
use crate::ip_addr_wrapper::IpAddrWrapper;
use crate::{REQUEST_LOG_ENV_VAR, RESPONSE_LOG_ENV_VAR};
/// Run a local instance of Starknet Devnet
#[derive(Parser, Debug)]
#[command(
author,
version,
about = "A local testnet for Starknet... in Rust!",
long_about = "Documentation: https://0xspaceshard.github.io/starknet-devnet",
propagate_version = true
)]
pub(crate) struct Args {
/// Number of accounts
#[arg(long = "accounts")]
#[arg(env = "ACCOUNTS")]
#[arg(value_name = "NUMBER")]
#[arg(default_value_t = DEVNET_DEFAULT_TOTAL_ACCOUNTS)]
#[arg(help = "Specify the number of accounts to be predeployed;")]
accounts_count: u8,
/// Class used for account predeployment
#[arg(long = "account-class")]
#[arg(env = "ACCOUNT_CLASS")]
#[arg(value_name = "ACCOUNT_CLASS")]
#[arg(default_value = "cairo1")]
#[arg(help = "Specify the class used by predeployed accounts;")]
account_class_choice: AccountContractClassChoice,
#[arg(long = "account-class-custom")]
#[arg(env = "ACCOUNT_CLASS_CUSTOM")]
#[arg(value_name = "PATH")]
#[arg(conflicts_with = "account_class_choice")]
#[arg(help = "Specify the path to a Cairo Sierra artifact to be used by predeployed accounts;")]
account_class_custom: Option<AccountClassWrapper>,
#[arg(long = "predeclare-argent")]
#[arg(env = "PREDECLARE_ARGENT")]
#[arg(help = format!(
"If set, predeclares Argent account contract classes: regular ({ARGENT_CONTRACT_VERSION}) \
and multisig ({ARGENT_MULTISIG_CONTRACT_VERSION}); does not affect account predeployment;"
))]
predeclare_argent: bool,
/// Initial balance of predeployed accounts
#[arg(long = "initial-balance")]
#[arg(env = "INITIAL_BALANCE")]
#[arg(short = 'e')]
#[arg(value_name = "DECIMAL_VALUE")]
#[arg(default_value_t = InitialBalanceWrapper::default())]
#[arg(help = "Specify the initial balance of accounts to be predeployed; the value is \
interpreted as WEI for ETH balance and FRI for STRK balance;")]
initial_balance: InitialBalanceWrapper,
// Seed for predeployed accounts
#[arg(long = "seed")]
#[arg(env = "SEED")]
#[arg(value_name = "SEED")]
#[arg(help = "Specify the seed for randomness of accounts to be predeployed; if not \
provided, it is randomly generated")]
seed: Option<u32>,
// Host address
#[arg(long = "host")]
#[arg(env = "HOST")]
#[arg(value_name = "HOST")]
#[arg(default_value_t = IpAddrWrapper::LOCALHOST)]
#[arg(help = "Specify the address to listen at;")]
host: IpAddrWrapper,
// Port number
#[arg(long = "port")]
#[arg(env = "PORT")]
#[arg(value_name = "PORT")]
#[arg(default_value_t = DEVNET_DEFAULT_PORT)]
#[arg(help = "Specify the port to listen at; If 0, acquires a random free port and prints it;")]
port: u16,
// Set start time in seconds
#[arg(long = "start-time")]
#[arg(env = "START_TIME")]
#[arg(value_name = "SECONDS")]
#[arg(help = "Specify start time in seconds;")]
start_time: Option<u64>,
// Server timeout in seconds
#[arg(long = "timeout")]
#[arg(env = "TIMEOUT")]
#[arg(value_name = "SECONDS")]
#[arg(default_value_t = DEVNET_DEFAULT_TIMEOUT)]
#[arg(help = "Specify the server timeout in seconds;")]
timeout: u16,
// Gas price in wei
#[arg(long = "gas-price")]
#[arg(env = "GAS_PRICE")]
#[arg(value_name = "WEI_PER_GAS_UNIT")]
#[arg(default_value_t = DEVNET_DEFAULT_L1_GAS_PRICE)]
#[arg(help = "Specify the gas price in wei per L1 gas unit;")]
gas_price_wei: NonZeroU128,
// Gas price in fri
#[arg(long = "gas-price-fri")]
#[arg(env = "GAS_PRICE_FRI")]
#[arg(value_name = "FRI_PER_GAS_UNIT")]
#[arg(default_value_t = DEVNET_DEFAULT_L1_GAS_PRICE)]
#[arg(help = "Specify the gas price in fri per L1 gas unit;")]
gas_price_fri: NonZeroU128,
// TODO perhaps make this affect only fri and remove -fri flags
// Gas price in wei
#[arg(long = "data-gas-price")]
#[arg(env = "DATA_GAS_PRICE")]
#[arg(value_name = "WEI_PER_GAS_UNIT")]
#[arg(default_value_t = DEVNET_DEFAULT_L1_DATA_GAS_PRICE)]
#[arg(help = "Specify the gas price in wei per L1 data gas unit;")]
data_gas_price_wei: NonZeroU128,
// Gas price in fri
#[arg(long = "data-gas-price-fri")]
#[arg(env = "DATA_GAS_PRICE_FRI")]
#[arg(value_name = "FRI_PER_GAS_UNIT")]
#[arg(default_value_t = DEVNET_DEFAULT_L1_DATA_GAS_PRICE)]
#[arg(help = "Specify the gas price in fri per L1 data gas unit;")]
data_gas_price_fri: NonZeroU128,
// L2 Gas price in wei
#[arg(long = "l2-gas-price")]
#[arg(env = "L2_GAS_PRICE")]
#[arg(value_name = "WEI_PER_GAS_UNIT")]
#[arg(default_value_t = DEVNET_DEFAULT_L2_GAS_PRICE)]
#[arg(help = "Specify the gas price in wei per L2 gas unit;")]
l2_gas_price_wei: NonZeroU128,
// L2 Gas price in fri
#[arg(long = "l2-gas-price-fri")]
#[arg(env = "L2_GAS_PRICE_FRI")]
#[arg(value_name = "FRI_PER_GAS_UNIT")]
#[arg(default_value_t = DEVNET_DEFAULT_L2_GAS_PRICE)]
#[arg(help = "Specify the gas price in fri per L2 gas unit;")]
l2_gas_price_fri: NonZeroU128,
#[arg(long = "chain-id")]
#[arg(env = "CHAIN_ID")]
#[arg(value_name = "CHAIN_ID")]
#[arg(default_value = "TESTNET")]
#[arg(help = "Specify the chain ID. Possible values are:
- \"MAINNET\", \"TESTNET\" - predefined chain IDs
- <USER_SUPPLIED> - custom chain ID, defined by user. Have to contain only ASCII characters.")]
#[arg(conflicts_with = "fork_network")]
chain_id: ChainId,
#[arg(long = "dump-on")]
#[arg(env = "DUMP_ON")]
#[arg(value_name = "EVENT")]
#[arg(help = "Specify when to dump the state of Devnet;")]
dump_on: Option<DumpOn>,
#[arg(long = "lite-mode")]
#[arg(env = "LITE_MODE")]
#[arg(help = "Specify whether to run in lite mode and skip block hash calculation;")]
lite_mode: bool,
// Dump path as string
#[arg(long = "dump-path")]
#[arg(env = "DUMP_PATH")]
#[arg(value_name = "DUMP_PATH")]
#[arg(help = "Specify the path to dump to;")]
#[arg(required_if_eq_any([("dump_on", "exit"), ("dump_on", "block")]))]
dump_path: Option<String>,
#[arg(long = "block-generation-on")]
#[arg(env = "BLOCK_GENERATION_ON")]
#[arg(default_value = "transaction")]
#[arg(help = "Specify when to generate a new block. Possible values are:
- \"transaction\" - new block generated on each transaction
- \"demand\" - new block creatable solely by calling the devnet_createBlock JSON-RPC method
- <INTERVAL> - a positive integer indicating after how many seconds a new block is generated
Calling devnet_createBlock JSON-RPC method is also an option in modes other than \"demand\".")]
block_generation_on: BlockGenerationOn,
#[arg(long = "state-archive-capacity")]
#[arg(env = "STATE_ARCHIVE_CAPACITY")]
#[arg(value_name = "STATE_ARCHIVE_CAPACITY")]
#[arg(default_value = "none")]
#[arg(help = "Specify the state archive capacity;")]
state_archive: StateArchiveCapacity,
#[arg(long = "fork-network")]
#[arg(env = "FORK_NETWORK")]
#[arg(value_name = "URL")]
#[arg(help = "Specify the URL of the network to fork;")]
fork_network: Option<url::Url>,
#[arg(long = "fork-block")]
#[arg(env = "FORK_BLOCK")]
#[arg(value_name = "BLOCK_NUMBER")]
#[arg(help = "Specify the number of the block to fork at;")]
#[arg(requires = "fork_network")]
fork_block: Option<u64>,
#[arg(long = "restrictive-mode")]
#[arg(env = "RESTRICTIVE_MODE")]
#[arg(num_args = 0..)]
#[arg(help = "Use Devnet in restrictive mode; You can specify the methods that will be \
forbidden with whitespace-separated values (https://0xspaceshard.github.io/starknet-devnet/docs/restrictive#with-a-list-of-methods). If nothing is specified for this \
argument, then default restricted methods are used (https://0xspaceshard.github.io/starknet-devnet/docs/restrictive#default-restricted-methods).")]
restricted_methods: Option<Vec<String>>,
#[arg(long = "maximum-contract-class-size")]
#[arg(env = "MAXIMUM_CONTRACT_CLASS_SIZE")]
#[arg(value_name = "BYTES")]
#[arg(default_value_t = MAXIMUM_CONTRACT_CLASS_SIZE)]
maximum_contract_class_size: u64,
#[arg(long = "maximum-contract-bytecode-size")]
#[arg(env = "MAXIMUM_CONTRACT_BYTECODE_SIZE")]
#[arg(value_name = "FELTS")]
#[arg(default_value_t = MAXIMUM_CONTRACT_BYTECODE_SIZE)]
maximum_contract_bytecode_size: u64,
#[arg(long = "maximum-sierra-length")]
#[arg(env = "MAXIMUM_SIERRA_LENGTH")]
#[arg(value_name = "FELTS")]
#[arg(default_value_t = MAXIMUM_SIERRA_LENGTH)]
maximum_sierra_length: u64,
}
impl Args {
pub(crate) fn to_config(&self) -> Result<(StarknetConfig, ServerConfig), anyhow::Error> {
// use account-class-custom if specified; otherwise default to predefined account-class
let account_class_wrapper = match &self.account_class_custom {
Some(account_class_custom) => account_class_custom.clone(),
None => self.account_class_choice.get_class_wrapper()?,
};
let starknet_config = StarknetConfig {
seed: match self.seed {
Some(seed) => seed,
None => generate_u32_random_number(),
},
total_accounts: self.accounts_count,
account_contract_class: account_class_wrapper.contract_class,
account_contract_class_hash: account_class_wrapper.class_hash,
predeployed_accounts_initial_balance: self.initial_balance.0.clone(),
start_time: self.start_time,
gas_price_wei: self.gas_price_wei,
gas_price_fri: self.gas_price_fri,
data_gas_price_wei: self.data_gas_price_wei,
data_gas_price_fri: self.data_gas_price_fri,
l2_gas_price_wei: self.l2_gas_price_wei,
l2_gas_price_fri: self.l2_gas_price_fri,
chain_id: self.chain_id,
dump_on: self.dump_on,
dump_path: self.dump_path.clone(),
block_generation_on: self.block_generation_on,
lite_mode: self.lite_mode,
state_archive: self.state_archive,
fork_config: ForkConfig {
url: self.fork_network.clone(),
block_number: self.fork_block,
block_hash: None,
},
predeclare_argent: self.predeclare_argent,
class_size_config: ClassSizeConfig {
maximum_contract_class_size: self.maximum_contract_class_size,
maximum_contract_bytecode_size: self.maximum_contract_bytecode_size,
maximum_sierra_length: self.maximum_sierra_length,
},
..Default::default()
};
let RequestResponseLogging { log_request, log_response } =
RequestResponseLogging::from_rust_log_environment_variable();
self.validate_total_account_balance()?;
let server_config = ServerConfig {
host: self.host.inner,
port: self.port,
timeout: self.timeout,
log_request,
log_response,
restricted_methods: self.get_validated_restricted_methods()?,
};
Ok((starknet_config, server_config))
}
/// n_accounts * balance(single_account) + chargeable_balance < u256 capacity
fn validate_total_account_balance(&self) -> Result<(), anyhow::Error> {
let total_supply = self.accounts_count * self.initial_balance.0.clone()
+ chargeable_account_initial_balance();
if total_supply >= (BigUint::from(1_u32) << 256) {
anyhow::bail!(
"Total balance supply in ERC20 contract exceeded. Reduce the number of \
predeployed accounts (--accounts) or their initial balance (--initial-balance)."
)
}
Ok(())
}
/// Errors if there are unsupported restricted methods/routes.
fn get_validated_restricted_methods(&self) -> Result<Option<Vec<String>>, anyhow::Error> {
match &self.restricted_methods {
None => Ok(None),
Some(methods) if methods.is_empty() => Ok(Some(
DEFAULT_RESTRICTED_JSON_RPC_METHODS.iter().map(|m| m.to_string()).collect(),
)),
Some(methods) => {
let json_rpc_methods = JsonRpcRequest::all_variants_serde_renames();
let wrong_restricted_methods: Vec<_> = methods
.iter()
.filter(|method| !json_rpc_methods.contains(method))
.cloned()
.collect();
if !wrong_restricted_methods.is_empty() {
anyhow::bail!(
"Restricted methods contain unsupported JSON-RPC methods: {}",
wrong_restricted_methods.join(", ")
);
}
Ok(Some(methods.clone()))
}
}
}
}
struct RequestResponseLogging {
log_request: bool,
log_response: bool,
}
impl RequestResponseLogging {
fn from_rust_log_environment_variable() -> Self {
let log_env_var = std::env::var(EnvFilter::DEFAULT_ENV).unwrap_or_default().to_lowercase();
let log_request = log_env_var.contains(REQUEST_LOG_ENV_VAR);
let log_response = log_env_var.contains(RESPONSE_LOG_ENV_VAR);
Self { log_request, log_response }
}
}
#[cfg(test)]
mod tests {
use clap::Parser;
use starknet_core::constants::CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH;
use starknet_core::starknet::starknet_config::{
BlockGenerationOn, DumpOn, StateArchiveCapacity,
};
use starknet_types::num_bigint::BigUint;
use tracing_subscriber::EnvFilter;
use super::{Args, RequestResponseLogging};
use crate::ip_addr_wrapper::IpAddrWrapper;
const CAIRO_0_ERC20_CONTRACT_PATH: &str =
"../../contracts/test_artifacts/cairo0/ERC20_Mintable_OZ_0.2.0.json";
#[test]
fn valid_ip_address() {
Args::parse_from(["--", "--host", "127.0.0.1"]);
}
#[test]
fn invalid_ip_address() {
let invalid_ip_address = "127.0.0";
match Args::try_parse_from(["--", "--host", invalid_ip_address]) {
Err(_) => (),
Ok(parsed) => panic!("Should have failed; got: {parsed:?}"),
}
}
#[test]
fn localhost_mapped() {
let args = Args::parse_from(["--", "--host", "localhost"]);
assert_eq!(args.host, IpAddrWrapper::LOCALHOST);
}
#[test]
fn invalid_hostname() {
match Args::try_parse_from(["--", "--host", "invalid"]) {
Err(_) => (),
Ok(parsed) => panic!("Should have failed; got: {parsed:?}"),
}
}
#[test]
fn state_archive_default_none() {
let args = Args::parse_from(["--"]);
let (starknet_config, _) = args.to_config().unwrap();
assert_eq!(starknet_config.state_archive, StateArchiveCapacity::None);
}
#[test]
fn state_archive_none() {
let args = Args::parse_from(["--", "--state-archive-capacity", "none"]);
let (starknet_config, _) = args.to_config().unwrap();
assert_eq!(starknet_config.state_archive, StateArchiveCapacity::None);
}
#[test]
fn state_archive_full() {
let args = Args::parse_from(["--", "--state-archive-capacity", "full"]);
let (starknet_config, _) = args.to_config().unwrap();
assert_eq!(starknet_config.state_archive, StateArchiveCapacity::Full);
}
fn get_first_line(text: &str) -> &str {
text.split('\n').next().unwrap()
}
#[test]
fn not_allowing_account_class_and_account_class_path() {
match Args::try_parse_from([
"--",
"--account-class",
"cairo1",
"--account-class-custom",
CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH,
]) {
Err(err) => {
assert_eq!(
get_first_line(&err.to_string()),
"error: the argument '--account-class <ACCOUNT_CLASS>' cannot be used with \
'--account-class-custom <PATH>'"
);
}
Ok(parsed) => panic!("Should have failed; got: {parsed:?}"),
}
}
#[test]
fn allowing_if_only_account_class() {
match Args::try_parse_from(["--", "--account-class", "cairo1"]) {
Ok(_) => (),
Err(err) => panic!("Should have passed; got: {err}"),
}
}
#[test]
fn allowing_if_only_account_class_path() {
match Args::try_parse_from([
"--",
"--account-class-custom",
CAIRO_1_ACCOUNT_CONTRACT_SIERRA_PATH,
]) {
Ok(_) => (),
Err(err) => panic!("Should have passed; got: {err}"),
}
}
#[test]
fn not_allowing_regular_cairo0_contract_as_custom_account() {
let custom_path = CAIRO_0_ERC20_CONTRACT_PATH;
match Args::try_parse_from(["--", "--account-class-custom", custom_path]) {
Err(err) => assert_eq!(
get_first_line(&err.to_string()),
format!(
"error: invalid value '{custom_path}' for '--account-class-custom <PATH>': \
Types error: missing field `kind` at line 1 column 292"
)
),
Ok(parsed) => panic!("Should have failed; got: {parsed:?}"),
}
}
#[test]
fn not_allowing_regular_cairo1_contract_as_custom_account() {
// path to a regular cairo1 contract (not an account)
let custom_path = "../../contracts/test_artifacts/cairo1/simple_contract/output.sierra";
match Args::try_parse_from(["--", "--account-class-custom", custom_path]) {
Err(err) => assert_eq!(
get_first_line(&err.to_string()),
format!(
"error: invalid value '{custom_path}' for '--account-class-custom <PATH>': \
Failed to load ContractClass: Not a valid Sierra account artifact; has \
__execute__: false; has __validate__: false"
)
),
Ok(parsed) => panic!("Should have failed; got: {parsed:?}"),
}
}
#[test]
fn not_allowing_invalid_url_as_fork_network() {
for url in ["abc", "", "http://"] {
match Args::try_parse_from(["--", "--fork-network", url]) {
Err(_) => (),
Ok(parsed) => panic!("Should fail for {url}; got: {parsed:?}"),
}
}
}
#[test]
fn allowing_valid_url_as_fork_network() {
for url in [
"https://free-rpc.nethermind.io/mainnet-juno/v0_6",
"http://localhost/",
"http://localhost:5051/",
"http://127.0.0.1/",
"http://127.0.0.1:5050/",
"https://localhost/",
"https://localhost:5050/",
] {
match Args::try_parse_from(["--", "--fork-network", url]) {
Ok(args) => assert_eq!(args.fork_network.unwrap().to_string(), url),
Err(e) => panic!("Should have passed; got: {e}"),
}
}
}
#[test]
fn not_allowing_fork_block_without_fork_network() {
match Args::try_parse_from(["--", "--fork-block", "12"]) {
Err(_) => (),
Ok(parsed) => panic!("Should fail when just --fork-block got: {parsed:?}"),
}
}
#[test]
fn not_allowing_invalid_value_as_fork_block() {
for number in ["", "abc", "-1"] {
match Args::try_parse_from([
"--",
"--fork-network",
"http://localhost:5051",
"--fork-block",
number,
]) {
Err(_) => (),
Ok(parsed) => panic!("Should fail for {number}; got: {parsed:?}"),
}
}
}
#[test]
fn allowing_number_as_fork_block() {
for number in [0, 1, 42, 999] {
match Args::try_parse_from([
"--",
"--fork-network",
"http://localhost:5051",
"--fork-block",
&number.to_string(),
]) {
Ok(args) => assert_eq!(args.fork_block, Some(number)),
Err(e) => panic!("Should have passed; got: {e}"),
}
}
}
#[test]
#[serial_test::serial]
fn test_variants_of_env_var() {
for (environment_variable, should_log_request, should_log_response) in [
("request,response,info", true, true),
("request,info", true, false),
("response,info", false, true),
("info", false, false),
("", false, false),
("REQUEST,RESPONSE", true, true),
("REQUEST", true, false),
("RESPONSE", false, true),
] {
unsafe {
std::env::set_var(EnvFilter::DEFAULT_ENV, environment_variable);
}
let RequestResponseLogging { log_request, log_response } =
RequestResponseLogging::from_rust_log_environment_variable();
assert_eq!(log_request, should_log_request);
assert_eq!(log_response, should_log_response);
}
}
#[test]
#[serial_test::serial]
fn test_env_vars_have_same_effect_as_cli_params() {
let config_source = [
("--accounts", "ACCOUNTS", "1"),
("--account-class", "ACCOUNT_CLASS", "cairo0"),
("--initial-balance", "INITIAL_BALANCE", "1"),
("--seed", "SEED", "43"),
("--port", "PORT", "1234"),
("--start-time", "START_TIME", "123"),
("--timeout", "TIMEOUT", "12"),
("--gas-price", "GAS_PRICE", "1"),
("--gas-price-fri", "GAS_PRICE_FRI", "2"),
("--data-gas-price", "DATA_GAS_PRICE", "3"),
("--data-gas-price-fri", "DATA_GAS_PRICE_FRI", "4"),
("--dump-on", "DUMP_ON", "exit"),
("--dump-path", "DUMP_PATH", "dummy-path"),
("--state-archive-capacity", "STATE_ARCHIVE_CAPACITY", "full"),
("--fork-network", "FORK_NETWORK", "http://dummy.com"),
("--fork-block", "FORK_BLOCK", "42"),
("--block-generation-on", "BLOCK_GENERATION_ON", "demand"),
];
let mut cli_args = vec!["--"];
for (cli_param, _, value) in config_source {
cli_args.push(cli_param);
cli_args.push(value);
}
let config_via_cli = Args::parse_from(cli_args).to_config().unwrap();
for (_, var_name, value) in config_source {
unsafe {
std::env::set_var(var_name, value);
}
}
let config_via_env = Args::parse_from(["--"]).to_config().unwrap();
assert_eq!(
serde_json::to_value(config_via_cli).unwrap(),
serde_json::to_value(config_via_env).unwrap()
);
// remove var to avoid collision with other tests
for (_, var_name, _) in config_source {
unsafe {
std::env::remove_var(var_name);
}
}
}
#[test]
#[serial_test::serial]
fn test_boolean_param_specification_via_env_vars() {
let config_source =
[("--lite-mode", "LITE_MODE"), ("--predeclare-argent", "PREDECLARE_ARGENT")];
let mut cli_args = vec!["--"];
for (cli_param, _) in config_source {
cli_args.push(cli_param);
}
let mut config_via_cli =
serde_json::to_value(Args::parse_from(cli_args).to_config().unwrap()).unwrap();
for (_, var_name) in config_source {
unsafe {
std::env::set_var(var_name, "true");
}
}
let mut config_via_env =
serde_json::to_value(Args::parse_from(["--"]).to_config().unwrap()).unwrap();
// Removing seed as it is generated randomly - it would make the compared objects different.
// to_config returns two config parts, so using index 0 to address starknet_config.
config_via_cli[0]["seed"].take();
config_via_env[0]["seed"].take();
assert_eq!(config_via_cli, config_via_env);
// remove var to avoid collision with other tests
for (var_name, _) in config_source {
unsafe {
std::env::remove_var(var_name);
}
}
}
#[test]
fn not_allowing_invalid_values_as_block_generation_interval() {
for interval in ["", "0", "-1", "abc"] {
match Args::try_parse_from(["--", "--block-generation-on", interval]) {
Err(_) => (),
Ok(parsed) => panic!("Should fail for {interval}; got: {parsed:?}"),
}
}
}
#[test]
fn allowing_valid_values_as_block_generation_interval() {
match Args::try_parse_from(["--", "--block-generation-on", "1"]) {
Ok(args) => assert_eq!(args.block_generation_on, BlockGenerationOn::Interval(1)),
Err(e) => panic!("Should have passed; got: {e}"),
}
match Args::try_parse_from(["--", "--block-generation-on", "demand"]) {
Ok(args) => assert_eq!(args.block_generation_on, BlockGenerationOn::Demand),
Err(e) => panic!("Should have passed; got: {e}"),
}
match Args::try_parse_from(["--", "--block-generation-on", "transaction"]) {
Ok(args) => assert_eq!(args.block_generation_on, BlockGenerationOn::Transaction),
Err(e) => panic!("Should have passed; got: {e}"),
}
}
#[test]
fn test_when_dump_path_flag_required() {
for event in ["exit", "block"] {
match Args::try_parse_from(["--", "--dump-on", event]) {
Ok(args) => panic!("Should have failed; got: {args:?}"),
Err(e) => assert_eq!(
get_first_line(&e.to_string()),
"error: the following required arguments were not provided:"
),
}
}
match Args::try_parse_from(["--", "--dump-on", "request"]) {
Ok(Args { dump_on: Some(DumpOn::Request), .. }) => (),
other => panic!("Invalid arg parse result: {other:?}"),
}
}
#[test]
fn invalid_dump_path_not_allowed() {
match Args::try_parse_from(["--", "--dump-path", "dump_wrong_cli_mode", "--dump-on", "e"]) {
Ok(args) => panic!("Should have failed; got: {args:?}"),
Err(e) => assert_eq!(
get_first_line(&e.to_string()),
"error: invalid value 'e' for '--dump-on <EVENT>'"
),
}
}
#[test]
fn check_if_method_with_incorrect_name_will_produce_an_error() {
let args = Args::parse_from([
"--",
"--restrictive-mode",
"devnet_dump",
"devnet_loadd",
"xyz",
"/mint",
]);
let err = args.to_config().unwrap_err();
assert!(err.to_string().contains(
"Restricted methods contain unsupported JSON-RPC methods: devnet_loadd, xyz, /mint"
));
}
#[test]
fn check_if_methods_with_correct_names_will_not_produce_an_error() {
Args::parse_from(["--", "--restrictive-mode"]).to_config().unwrap();
Args::parse_from(["--", "--restrictive-mode", "devnet_dump", "devnet_mint"])
.to_config()
.unwrap();
}
#[test]
fn should_not_exceed_total_supply() {
let initial_balance: BigUint = (BigUint::from(1_u32) << 254) - 1_u32;
Args::parse_from([
"--",
"--accounts",
"2",
"--initial-balance",
&initial_balance.to_str_radix(10),
])
.to_config()
.unwrap();
}
#[test]
/// Fails because 2 * (2 ** 254) + (2 ** 255) = 2 ** 256
fn should_fail_on_exceeded_total_supply() {
let initial_balance: BigUint = BigUint::from(1_u32) << 254;
let err = Args::parse_from([
"--",
"--accounts",
"2",
"--initial-balance",
&initial_balance.to_str_radix(10),
])
.to_config()
.unwrap_err();
assert!(err.to_string().contains(
"Total balance supply in ERC20 contract exceeded. Reduce the number of predeployed \
accounts (--accounts) or their initial balance (--initial-balance)."
))
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
0xSpaceShard/starknet-devnet | https://github.com/0xSpaceShard/starknet-devnet/blob/64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed/crates/starknet-devnet/src/main.rs | crates/starknet-devnet/src/main.rs | use std::future::IntoFuture;
use std::net::IpAddr;
use std::result::Result::Ok;
use std::time::Duration;
use clap::Parser;
use cli::Args;
use futures::future::join_all;
use serde::de::IntoDeserializer;
use serde_json::json;
use server::api::{Api, JsonRpcHandler, RPC_SPEC_VERSION};
use server::dump_util::{dump_events, load_events};
use server::server::serve_http_json_rpc;
use starknet_core::account::Account;
use starknet_core::constants::{
ARGENT_CONTRACT_CLASS_HASH, ARGENT_MULTISIG_CONTRACT_CLASS_HASH, ETH_ERC20_CONTRACT_ADDRESS,
STRK_ERC20_CONTRACT_ADDRESS, UDC_CONTRACT_ADDRESS, UDC_CONTRACT_CLASS_HASH,
};
use starknet_core::starknet::Starknet;
use starknet_core::starknet::starknet_config::{
BlockGenerationOn, DumpOn, ForkConfig, StarknetConfig,
};
use starknet_rs_core::types::ContractClass::{Legacy, Sierra};
use starknet_rs_core::types::{
BlockId, BlockTag, Felt, MaybePreConfirmedBlockWithTxHashes, StarknetError,
};
use starknet_rs_providers::jsonrpc::HttpTransport;
use starknet_rs_providers::{JsonRpcClient, Provider, ProviderError};
use starknet_types::chain_id::ChainId;
use starknet_types::rpc::state::Balance;
use starknet_types::serde_helpers::rpc_sierra_contract_class_to_sierra_contract_class::deserialize_to_sierra_contract_class;
use tokio::io::AsyncWriteExt;
use tokio::net::{TcpListener, UnixStream};
#[cfg(unix)]
use tokio::signal::unix::{SignalKind, signal};
#[cfg(windows)]
use tokio::signal::windows::ctrl_c;
use tokio::task::{self};
use tokio::time::{interval, sleep};
use tracing::{error, info, warn};
use tracing_subscriber::EnvFilter;
mod cli;
mod initial_balance_wrapper;
mod ip_addr_wrapper;
const REQUEST_LOG_ENV_VAR: &str = "request";
const RESPONSE_LOG_ENV_VAR: &str = "response";
/// Configures tracing with default level INFO,
/// If the environment variable `RUST_LOG` is set, it will be used instead.
/// Added are two more directives: `request` and `response`. If they are present, then have to be
/// removed to be able to construct the `EnvFilter` correctly, because tracing_subscriber recognizes
/// them as path syntax (way to access a module) and assigns them TRACE level. Because they are not
/// paths to some module like this one: `starknet-devnet::cli` nothing gets logged. For example:
/// `RUST_LOG=request` is translated to `request=TRACE`, which means that will log TRACE level for
/// request module.
fn configure_tracing() {
let log_env_var = std::env::var(EnvFilter::DEFAULT_ENV).unwrap_or_default().to_lowercase();
// Remove the `request` and `response` directives from the environment variable.
// And trim empty spaces around each directive
let log_env_var = log_env_var
.split(',')
.map(|el| el.trim())
.filter(|el| ![REQUEST_LOG_ENV_VAR, RESPONSE_LOG_ENV_VAR].contains(el))
.collect::<Vec<&str>>()
.join(",");
let level_filter_layer = EnvFilter::builder()
.with_default_directive(tracing::Level::INFO.into())
.parse_lossy(log_env_var);
tracing_subscriber::fmt().with_env_filter(level_filter_layer).init();
}
fn log_predeployed_accounts(
predeployed_accounts: &Vec<Account>,
seed: u32,
initial_balance: Balance,
) {
if let Some(predeployed_account) = predeployed_accounts.first() {
println!(
"Predeployed accounts using class {} with hash: {}",
predeployed_account.class_metadata,
predeployed_account.class_hash.to_fixed_hex_string()
);
}
for account in predeployed_accounts {
println!(
r"
| Account address | {}
| Private key | {}
| Public key | {}",
account.account_address.to_fixed_hex_string(),
account.keys.private_key.to_fixed_hex_string(),
account.keys.public_key.to_fixed_hex_string()
);
}
if !predeployed_accounts.is_empty() {
println!();
println!("Initial balance of each account: {initial_balance} WEI and FRI");
println!("Seed to replicate this account sequence: {seed}");
println!();
}
}
fn log_predeployed_contracts(config: &StarknetConfig) {
println!("Predeployed FeeToken");
println!("ETH Address: 0x{:X}", ETH_ERC20_CONTRACT_ADDRESS);
println!("Class Hash: 0x{:X}", config.eth_erc20_class_hash);
println!("STRK Address: 0x{:X}", STRK_ERC20_CONTRACT_ADDRESS);
println!("Class Hash: 0x{:X}", config.strk_erc20_class_hash);
println!();
println!("Predeployed UDC");
println!("Address: 0x{:X}", UDC_CONTRACT_ADDRESS);
println!("Class Hash: 0x{:X}", UDC_CONTRACT_CLASS_HASH);
println!();
}
fn log_other_predeclared_contracts(config: &StarknetConfig) {
if config.predeclare_argent {
println!("Predeclared Argent account classes");
println!("Regular class hash: 0x{:X}", ARGENT_CONTRACT_CLASS_HASH);
println!("Multisig class hash: 0x{:X}", ARGENT_MULTISIG_CONTRACT_CLASS_HASH);
println!();
}
}
fn log_chain_id(chain_id: &ChainId) {
println!("Chain ID: {} ({})", chain_id, chain_id.to_felt().to_hex_string());
println!();
}
async fn check_forking_spec_version(
client: &JsonRpcClient<HttpTransport>,
) -> Result<(), anyhow::Error> {
let origin_spec_version = client.spec_version().await?;
if origin_spec_version != RPC_SPEC_VERSION {
warn!(
"JSON-RPC API version of origin ({}) does not match this Devnet's version ({}).",
origin_spec_version, RPC_SPEC_VERSION
);
}
Ok(())
}
// Sets in the starknet_config the class hash and contract class of the ERC20 contracts if they are
// different from the default ones.
async fn set_erc20_contract_class_and_class_hash_if_different_than_default(
json_rpc_client: &JsonRpcClient<HttpTransport>,
starknet_config: &mut StarknetConfig,
) -> Result<(), anyhow::Error> {
let block_id = BlockId::Number(
starknet_config
.fork_config
.block_number
.ok_or(anyhow::anyhow!("Forking block number is not set"))?,
);
async fn get_origin_class_hash_and_contract_class_if_different_from_default(
json_rpc_client: &JsonRpcClient<HttpTransport>,
block_id: BlockId,
contract_address: Felt,
default_class_hash: Felt,
) -> Result<Option<(Felt, String)>, anyhow::Error> {
match json_rpc_client.get_class_hash_at(block_id, contract_address).await {
Ok(origin_class_hash) => {
if origin_class_hash != default_class_hash {
tracing::debug!(
"Found ERC20 class hash difference at address {contract_address:#x}; \
origin={origin_class_hash:#x}, default={default_class_hash:#x}. \
Replacing..."
);
let origin_contract_class =
json_rpc_client.get_class(block_id, origin_class_hash).await?;
let contract_class_json_str = match origin_contract_class {
Sierra(_) => {
let contract_class_json_value =
serde_json::to_value(origin_contract_class)?;
let sierra_contract_class = deserialize_to_sierra_contract_class(
contract_class_json_value.into_deserializer(),
)?;
serde_json::to_string(&sierra_contract_class)?
}
Legacy(_) => serde_json::to_string(&origin_contract_class)?,
};
Ok(Some((origin_class_hash, contract_class_json_str)))
} else {
Ok(None)
}
}
// if the contract is not found, then dont return an error. It means that the
// contract was not deployed at this state of the origin blockchain
Err(ProviderError::StarknetError(StarknetError::ContractNotFound)) => Ok(None),
Err(err) => Err(err.into()),
}
}
if let Some((class_hash, contract_class)) =
get_origin_class_hash_and_contract_class_if_different_from_default(
json_rpc_client,
block_id,
ETH_ERC20_CONTRACT_ADDRESS,
starknet_config.eth_erc20_class_hash,
)
.await?
{
starknet_config.eth_erc20_class_hash = class_hash;
starknet_config.eth_erc20_contract_class = contract_class;
}
if let Some((class_hash, contract_class)) =
get_origin_class_hash_and_contract_class_if_different_from_default(
json_rpc_client,
block_id,
STRK_ERC20_CONTRACT_ADDRESS,
starknet_config.strk_erc20_class_hash,
)
.await?
{
starknet_config.strk_erc20_class_hash = class_hash;
starknet_config.strk_erc20_contract_class = contract_class;
}
Ok(())
}
/// Logs forking info if forking specified. If block_number is not specified, it is set to the
/// latest block number.
pub async fn set_and_log_fork_config(
fork_config: &mut ForkConfig,
json_rpc_client: &JsonRpcClient<HttpTransport>,
) -> Result<(), anyhow::Error> {
check_forking_spec_version(json_rpc_client).await?;
let block_id = fork_config.block_number.map_or(BlockId::Tag(BlockTag::Latest), BlockId::Number);
let block = json_rpc_client.get_block_with_tx_hashes(block_id).await.map_err(|e| {
anyhow::Error::msg(match e {
starknet_rs_providers::ProviderError::StarknetError(
starknet_rs_core::types::StarknetError::BlockNotFound,
) => format!("Forking from block {block_id:?}: block not found"),
_ => format!("Forking from block {block_id:?}: {e}; Check the URL"),
})
})?;
match block {
MaybePreConfirmedBlockWithTxHashes::Block(b) => {
fork_config.block_number = Some(b.block_number);
fork_config.block_hash = Some(b.block_hash);
info!("Forking from block: number={}, hash={:#x}", b.block_number, b.block_hash);
}
MaybePreConfirmedBlockWithTxHashes::PreConfirmedBlock(_) => {
error!(
"Block from origin deserialized as pre-confirmed. Most likely RPC version \
incompatibility."
);
std::process::exit(1);
}
};
Ok(())
}
async fn bind_port(
host: IpAddr,
specified_port: u16,
) -> Result<(String, TcpListener), anyhow::Error> {
let binding_address = format!("{host}:{specified_port}");
let listener = TcpListener::bind(binding_address.clone()).await?;
let acquired_port = listener.local_addr()?.port();
Ok((format!("{host}:{acquired_port}"), listener))
}
#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
let timestamp = std::time::Instant::now();
configure_tracing();
// parse arguments
let args = Args::parse();
let (mut starknet_config, server_config) = args.to_config()?;
// If fork url is provided, then set fork config and chain_id from forked network
if let Some(url) = starknet_config.fork_config.url.as_ref() {
let json_rpc_client = JsonRpcClient::new(HttpTransport::new(url.clone()));
set_and_log_fork_config(&mut starknet_config.fork_config, &json_rpc_client).await?;
set_erc20_contract_class_and_class_hash_if_different_than_default(
&json_rpc_client,
&mut starknet_config,
)
.await?;
// TODO: Add check for UDC contract
starknet_config.chain_id = json_rpc_client.chain_id().await?.into();
}
// shadow mutability of starknet_config
let starknet_config = starknet_config;
let mut starknet = Starknet::new(&starknet_config)?;
let (address, listener) = bind_port(server_config.host, server_config.port).await?;
// set block timestamp shift during startup if start time is set
if let Some(start_time) = starknet_config.start_time {
starknet.set_block_timestamp_shift(
start_time as i64 - Starknet::get_unix_timestamp_as_seconds() as i64,
);
};
log_chain_id(&starknet_config.chain_id);
log_predeployed_contracts(&starknet_config);
log_other_predeclared_contracts(&starknet_config);
log_predeployed_accounts(
&starknet.get_predeployed_accounts(),
starknet_config.seed,
starknet_config.predeployed_accounts_initial_balance.clone(),
);
let api = Api::new(starknet, server_config);
let json_rpc_handler = JsonRpcHandler::new(api.clone());
if let Some(dump_path) = &starknet_config.dump_path {
// Try to load events from the path. Since the same CLI parameter is used for dump and load
// path, it may be the case that there is no file at the path. This means that the file will
// be created during Devnet's lifetime via dumping, so its non-existence is here ignored.
match load_events(starknet_config.dump_on, dump_path) {
Ok(loadable_events) => json_rpc_handler
.re_execute(&loadable_events)
.await
.map_err(|e| anyhow::anyhow!("Failed to re-execute dumped Devnet: {e}"))?,
Err(starknet_core::error::Error::FileNotFound) => (),
Err(err) => return Err(err.into()),
}
};
let acquired_port = listener.local_addr()?.port();
let server = serve_http_json_rpc(listener, &api.server_config, json_rpc_handler).await;
info!("Starknet Devnet listening on {}", address);
#[cfg(unix)]
if let Ok(socket_path) = std::env::var("UNIX_SOCKET") {
match UnixStream::connect(&socket_path).await {
Ok(mut stream) => {
stream.write_all(&acquired_port.to_be_bytes()).await?;
stream.shutdown().await?;
println!("Successfully wrote port to unix socket: {}", socket_path);
}
Err(e) => {
println!("Couldn't connect to unix socket: {socket_path}, reason: {e}");
}
}
}
let mut tasks = vec![];
if let BlockGenerationOn::Interval(seconds) = starknet_config.block_generation_on {
// use JoinHandle to run block interval creation as a task
let full_address = format!("http://{address}");
let block_interval_handle = task::spawn(create_block_interval(seconds, full_address));
tasks.push(block_interval_handle);
}
// run server also as a JoinHandle
let server_handle =
task::spawn(server.with_graceful_shutdown(shutdown_signal(api)).into_future());
tasks.push(server_handle);
tracing::debug!("Starknet Devnet started in {:.2?}", timestamp.elapsed());
// join all tasks
let results = join_all(tasks).await;
// handle the results of the tasks
for result in results {
result??;
}
Ok(())
}
#[allow(clippy::expect_used)]
async fn create_block_interval(
block_interval_seconds: u64,
devnet_address: String,
) -> Result<(), std::io::Error> {
#[cfg(unix)]
let mut sigint = { signal(SignalKind::interrupt()).expect("Failed to setup SIGINT handler") };
#[cfg(windows)]
let mut sigint = {
let ctrl_c_signal = ctrl_c().expect("Failed to setup Ctrl+C handler");
Box::pin(ctrl_c_signal)
};
let devnet_client = reqwest::Client::new();
let block_req_body = json!({ "jsonrpc": "2.0", "id": 0, "method": "devnet_createBlock" });
// avoid creating block instantly after startup
sleep(Duration::from_secs(block_interval_seconds)).await;
let mut interval = interval(Duration::from_secs(block_interval_seconds));
loop {
tokio::select! {
_ = interval.tick() => {
// By sending a request, we take care of: 1) dumping 2) notifying subscribers
match devnet_client.post(&devnet_address).json(&block_req_body).send().await {
Ok(_) => info!("Generating block on time interval"),
Err(e) => error!("Failed block creation on time interval: {e:?}")
}
}
_ = sigint.recv() => {
return Ok(())
}
}
}
}
#[allow(clippy::expect_used)]
pub async fn shutdown_signal(api: Api) {
tokio::signal::ctrl_c().await.expect("Failed to install CTRL+C signal handler");
// dump on exit scenario
if let (Some(DumpOn::Exit), Some(dump_path)) = (api.config.dump_on, &api.config.dump_path) {
let events = { api.dumpable_events.lock().await.clone() };
dump_events(&events, dump_path).expect("Failed to dump.");
}
}
#[cfg(test)]
mod tests {
use tracing::level_filters::LevelFilter;
use tracing_subscriber::EnvFilter;
use crate::configure_tracing;
#[test]
fn test_generated_log_level_from_empty_environment_variable_is_info() {
assert_environment_variable_sets_expected_log_level("", LevelFilter::INFO);
}
fn assert_environment_variable_sets_expected_log_level(
env_var: &str,
expected_level: LevelFilter,
) {
unsafe {
std::env::set_var(EnvFilter::DEFAULT_ENV, env_var);
}
configure_tracing();
assert_eq!(LevelFilter::current(), expected_level);
}
}
| rust | MIT | 64b6efe29cd5215c8f4fe880cf1c97b3ee18a7ed | 2026-01-04T20:24:59.412401Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.