diff --git a/crates/core/generate-pie/src/block_processor.rs b/crates/core/generate-pie/src/block_processor.rs index eae78249..65d69d11 100644 --- a/crates/core/generate-pie/src/block_processor.rs +++ b/crates/core/generate-pie/src/block_processor.rs @@ -41,9 +41,6 @@ pub struct BlockInfoResult { pub accessed_classes: HashSet, /// Storage keys accessed by each contract address. pub accessed_keys_by_address: HashMap>, - /// The previous block ID (if any). - #[allow(dead_code)] - pub previous_block_id: Option, /// Classes migrated from Poseidon to BLAKE hash (SNIP-34). pub migrated_compiled_classes: HashMap, } @@ -168,7 +165,6 @@ pub async fn collect_single_block_info( accessed_addresses, accessed_classes, accessed_keys_by_address, - previous_block_id: if block_number == 0 { None } else { Some(BlockId::Number(block_number - 1)) }, migrated_compiled_classes, }) } diff --git a/crates/core/generate-pie/src/utils/misc.rs b/crates/core/generate-pie/src/utils/misc.rs index e8f5a4e2..8f7a46b5 100644 --- a/crates/core/generate-pie/src/utils/misc.rs +++ b/crates/core/generate-pie/src/utils/misc.rs @@ -1,9 +1,6 @@ use log::info; use num_traits::cast::ToPrimitive; -use serde::Serialize; use starknet_api::block::{GasPrice, GasPriceVector, NonzeroGasPrice}; -use std::fs::File; -use std::io::Write; use std::path::Path; use crate::error::FeltConversionError; @@ -29,64 +26,6 @@ pub fn felt_to_u128(felt: &Felt) -> Result { felt.to_u128().ok_or(FeltConversionError::OverflowError) } -/// Generic function to serialize any serializable object and write it to a file -/// -/// # Arguments -/// * `object` - Any object that implements the Serialize trait -/// * `file_path` - Path where the file should be written -/// * `format` - Optional format specification ("json", "yaml", etc.). Defaults to JSON. -/// -/// # Returns -/// * `Result<(), Box>` - Ok(()) on success, error on failure -/// -/// # Examples -/// ``` -/// let data = vec![1, 2, 3, 4, 5]; -/// write_serializable_to_file(&data, "output/numbers.json", Some("json"))?; -/// -/// let traces = get_transaction_traces(); -/// write_serializable_to_file(&traces, "debug/traces.json", None)?; -/// ``` -#[allow(dead_code)] -pub fn write_serializable_to_file( - object: &T, - file_path: &str, - format: Option<&str>, -) -> Result<(), Box> -where - T: Serialize, -{ - // Create a directory if it doesn't exist - if let Some(parent) = Path::new(file_path).parent() { - std::fs::create_dir_all(parent)?; - } - - let mut file = File::create(file_path)?; - - match format.unwrap_or("json") { - "json" => { - let json_string = serde_json::to_string_pretty(object)?; - file.write_all(json_string.as_bytes())?; - } - "json-compact" => { - let json_string = serde_json::to_string(object)?; - file.write_all(json_string.as_bytes())?; - } - #[cfg(feature = "yaml")] - "yaml" => { - let yaml_string = serde_yaml::to_string(object)?; - file.write_all(yaml_string.as_bytes())?; - } - _ => { - return Err(format!("Unsupported format: {}", format.unwrap_or("json")).into()); - } - } - - file.flush()?; - info!("Successfully wrote serialized data to: {}", file_path); - Ok(()) -} - /// Loads versioned constants from a file path if provided. /// /// This function handles loading versioned constants from a JSON file. diff --git a/crates/core/generate-pie/src/utils/rpc.rs b/crates/core/generate-pie/src/utils/rpc.rs index 3c359af2..8b3f54d6 100644 --- a/crates/core/generate-pie/src/utils/rpc.rs +++ b/crates/core/generate-pie/src/utils/rpc.rs @@ -13,7 +13,6 @@ use starknet_types_core::felt::Felt; use std::collections::{HashMap, HashSet}; /// Comprehensive structure that captures all access information from transaction execution -#[allow(dead_code)] #[derive(Debug, Clone)] pub struct BlockAccessInfo { /// Storage keys accessed per contract address diff --git a/crates/core/generate-pie/src/utils/serialization.rs b/crates/core/generate-pie/src/utils/serialization.rs index 251e0067..952a567e 100644 --- a/crates/core/generate-pie/src/utils/serialization.rs +++ b/crates/core/generate-pie/src/utils/serialization.rs @@ -1,201 +1,10 @@ //! Utilities for serialization and contract class processing. //! //! This module contains helper functions for: -//! - Serializing OS hints to JSON format //! - Processing and normalizing deprecated contract classes //! - JSON manipulation utilities for contract compatibility -use log::{debug, info}; -use serde_json::json; -use starknet_os::io::os_input::OsHints; - -use crate::error::PieGenerationError; - -// ================================================================================================ -// OS Hints Serialization -// ================================================================================================ - -/// Serializes OsHints to JSON format with complete data representation. -/// -/// Since OsHints may not implement Serialize directly, this function creates a comprehensive -/// custom serializable representation including all nested structures and metadata. -/// -/// # Arguments -/// -/// * `os_hints` - The OS hints structure to serialize -/// * `output_path` - Path where the JSON file should be written -/// -/// # Returns -/// -/// Returns `Ok(())` on success or `PieGenerationError` on failure. -/// -/// # Example -/// -/// ```rust -/// use generate_pie::utils::serialization::serialize_os_hints_to_json; -/// -/// let output_path = "os_hints_block_123.json"; -/// serialize_os_hints_to_json(&os_hints, output_path)?; -/// ``` -#[allow(dead_code)] -pub fn serialize_os_hints_to_json(os_hints: &OsHints, output_path: &str) -> Result<(), PieGenerationError> { - info!("Serializing OS hints to JSON file: {}", output_path); - - // Serialize OS hints config - let os_hints_config_json = json!({ - "debug_mode": os_hints.os_hints_config.debug_mode, - "full_output": os_hints.os_hints_config.full_output, - "use_kzg_da": os_hints.os_hints_config.use_kzg_da, - "chain_info": { - "chain_id": format!("{:?}", os_hints.os_hints_config.chain_info.chain_id), - "strk_fee_token_address": format!("{:#x}", os_hints.os_hints_config.chain_info.strk_fee_token_address.0.key()) - } - }); - - // Serialize block inputs completely - let block_inputs_json: Vec = os_hints.os_input.os_block_inputs.iter() - .map(|block_input| { - json!({ - "block_info": { - "block_number": block_input.block_info.block_number, - "sequencer_address": format!("{:#x}", block_input.block_info.sequencer_address.0.key()), - "block_timestamp": block_input.block_info.block_timestamp.0, - "use_kzg_da": block_input.block_info.use_kzg_da, - "gas_prices": { - "eth_gas_prices": format!("{:#?}", block_input.block_info.gas_prices.eth_gas_prices), - "strk_gas_prices": format!("{:#?}", block_input.block_info.gas_prices.strk_gas_prices), - } - }, - "transactions": block_input.transactions.iter().map(|tx| { - // Use Debug format for comprehensive transaction serialization - format!("{:#?}", tx) - }).collect::>(), - "tx_execution_infos": block_input.tx_execution_infos.iter().map(|exec_info| { - format!("{:#?}", exec_info) - }).collect::>(), - "contract_state_commitment_info": format!("{:#?}", block_input.contract_state_commitment_info), - "contract_class_commitment_info": format!("{:#?}", block_input.contract_class_commitment_info), - "address_to_storage_commitment_info": block_input.address_to_storage_commitment_info.iter().map(|(addr, commitment_info)| { - json!({ - "address": format!("{:#x}", addr.0.key()), - "commitment_info": format!("{:#?}", commitment_info) - }) - }).collect::>(), - "declared_class_hash_to_component_hashes": block_input.declared_class_hash_to_component_hashes.iter().map(|(class_hash, component_hashes)| { - json!({ - "class_hash": format!("{:#x}", class_hash.0), - "component_hashes": format!("{:#?}", component_hashes) - }) - }).collect::>(), - "prev_block_hash": format!("{:#x}", block_input.prev_block_hash.0), - "new_block_hash": format!("{:#x}", block_input.new_block_hash.0), - "old_block_number_and_hash": block_input.old_block_number_and_hash.as_ref().map(|(block_number, block_hash)| { - json!({ - "block_number": block_number.0, - "block_hash": format!("{:#x}", block_hash.0) - }) - }) - }) - }).collect(); - - // Serialize cached state inputs completely - let cached_state_inputs_json: Vec = os_hints.os_input.cached_state_inputs.iter() - .map(|cached_state| { - json!({ - "storage": cached_state.storage.iter().map(|(addr, storage_map)| { - json!({ - "address": format!("{:#x}", addr.0.key()), - "storage": storage_map.iter().map(|(key, value)| { - json!({ - "key": format!("{:#x}", key.0.key()), - "value": format!("{:#x}", value) - }) - }).collect::>() - }) - }).collect::>(), - "address_to_class_hash": cached_state.address_to_class_hash.iter().map(|(addr, class_hash)| { - json!({ - "address": format!("{:#x}", addr.0.key()), - "class_hash": format!("{:#x}", class_hash.0) - }) - }).collect::>(), - "address_to_nonce": cached_state.address_to_nonce.iter().map(|(addr, nonce)| { - json!({ - "address": format!("{:#x}", addr.0.key()), - "nonce": format!("{:#x}", nonce.0) - }) - }).collect::>(), - "class_hash_to_compiled_class_hash": cached_state.class_hash_to_compiled_class_hash.iter().map(|(class_hash, compiled_hash)| { - json!({ - "class_hash": format!("{:#x}", class_hash.0), - "compiled_class_hash": format!("{:#x}", compiled_hash.0) - }) - }).collect::>() - }) - }).collect(); - - // Serialize compiled classes completely - let compiled_classes_json: Vec = os_hints - .os_input - .compiled_classes - .iter() - .map(|(class_hash, compiled_class)| { - json!({ - "class_hash": format!("{:#x}", class_hash.0), - "compiled_class": format!("{:#?}", compiled_class) - }) - }) - .collect(); - - // Serialize deprecated compiled classes completely - let deprecated_compiled_classes_json: Vec = os_hints - .os_input - .deprecated_compiled_classes - .iter() - .map(|(class_hash, deprecated_compiled_class)| { - json!({ - "class_hash": format!("{:#x}", class_hash.0), - "deprecated_compiled_class": format!("{:#?}", deprecated_compiled_class) - }) - }) - .collect(); - - // Create the complete serializable representation - let complete_os_hints = json!({ - "os_hints_config": os_hints_config_json, - "os_input": { - "os_block_inputs": block_inputs_json, - "cached_state_inputs": cached_state_inputs_json, - "compiled_classes": compiled_classes_json, - "deprecated_compiled_classes": deprecated_compiled_classes_json - }, - "metadata": { - "serialization_timestamp": chrono::Utc::now().to_rfc3339(), - "serialization_note": "Complete serialization of OsHints including all nested structures and data.", - "statistics": { - "num_blocks": os_hints.os_input.os_block_inputs.len(), - "num_cached_states": os_hints.os_input.cached_state_inputs.len(), - "num_compiled_classes": os_hints.os_input.compiled_classes.len(), - "num_deprecated_compiled_classes": os_hints.os_input.deprecated_compiled_classes.len(), - "total_transactions": os_hints.os_input.os_block_inputs.iter() - .map(|block| block.transactions.len()) - .sum::(), - "block_numbers": os_hints.os_input.os_block_inputs.iter() - .map(|block_input| block_input.block_info.block_number) - .collect::>() - } - } - }); - - // Write to file - let json_string = serde_json::to_string_pretty(&complete_os_hints) - .map_err(|e| PieGenerationError::Io(std::io::Error::new(std::io::ErrorKind::InvalidData, e)))?; - - std::fs::write(output_path, json_string)?; - info!("Complete OS hints successfully serialized to: {}", output_path); - - Ok(()) -} +use log::debug; // ================================================================================================ // Contract Class Processing diff --git a/crates/rpc-client/src/types/proofs/class.rs b/crates/rpc-client/src/types/proofs/class.rs index 532cf25f..00b79800 100644 --- a/crates/rpc-client/src/types/proofs/class.rs +++ b/crates/rpc-client/src/types/proofs/class.rs @@ -1,34 +1,13 @@ use serde::{Deserialize, Serialize}; use starknet_core::types::StorageProof; -use starknet_types_core::felt::Felt; -use crate::error::ProofVerificationError; -use crate::types::{PoseidonHash, TrieNode}; +use crate::types::TrieNode; -#[allow(dead_code)] #[derive(Clone, Deserialize, Serialize)] pub struct ClassProof { - pub class_commitment: Felt, pub class_proof: Vec, } -// Implementations for ClassProof -impl ClassProof { - /// Gets the "class_commitment" which is aka the root node of the class Merkle tree. - /// - /// Proof always starts with the root node, which means all we have to do is hash the - /// first node in the proof to get the same thing. - #[allow(clippy::result_large_err)] - pub fn class_commitment(&self) -> Result { - if !self.class_proof.is_empty() { - let hash = self.class_proof[0].calculate_node_hash::(); - Ok(hash) - } else { - Err(ProofVerificationError::EmptyProof) - } - } -} - impl From for ClassProof { fn from(proof: StorageProof) -> Self { let class_proof = proof @@ -41,7 +20,6 @@ impl From for ClassProof { trie_node }) .collect(); - let class_commitment = proof.global_roots.classes_tree_root; - ClassProof { class_commitment, class_proof } + ClassProof { class_proof } } } diff --git a/crates/starknet-os-types/src/deprecated_compiled_class.rs b/crates/starknet-os-types/src/deprecated_compiled_class.rs index 5a1f36ed..f0002971 100644 --- a/crates/starknet-os-types/src/deprecated_compiled_class.rs +++ b/crates/starknet-os-types/src/deprecated_compiled_class.rs @@ -54,7 +54,6 @@ pub struct GenericDeprecatedCompiledClass { /// Lazy-initialized StarknetAPI contract class. starknet_api_contract_class: OnceCell>, /// Lazy-initialized StarknetCore contract class. - #[allow(dead_code)] starknet_core_contract_class: OnceCell>, /// Lazy-initialized serialized contract class bytes. serialized_class: OnceCell>,