Skip to content

apollo_gateway: removing usage of gateway trates in rpc_state_reader #11539

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
lev-starkware merged 1 commit into from
Jan 13, 2026
Merged

apollo_gateway: removing usage of gateway trates in rpc_state_reader #11539

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
86 changes: 1 addition & 85 deletions crates/apollo_gateway/src/rpc_state_reader.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,32 +1,24 @@
use apollo_gateway_config::config::RpcStateReaderConfig;
use apollo_gateway_types::deprecated_gateway_error::StarknetError;
use apollo_rpc::CompiledContractClass;
use apollo_state_sync_types::communication::StateSyncClientResult;
use async_trait::async_trait;
use blockifier::execution::contract_class::{
CompiledClassV0,
CompiledClassV1,
RunnableCompiledClass,
};
use blockifier::state::errors::StateError;
use blockifier::state::global_cache::CompiledClasses;
use blockifier::state::state_api::{StateReader as BlockifierStateReader, StateResult};
use blockifier::state::state_reader_and_contract_manager::FetchCompiledClasses;
use reqwest::blocking::Client as BlockingClient;
use serde::Serialize;
use serde_json::{json, Value};
use starknet_api::block::{BlockInfo, BlockNumber};
use starknet_api::block::BlockNumber;
use starknet_api::contract_class::SierraVersion;
use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce};
use starknet_api::state::StorageKey;
use starknet_types_core::felt::Felt;

use crate::errors::{serde_err_to_state_err, RPCStateReaderError, RPCStateReaderResult};
use crate::gateway_fixed_block_state_reader::{GatewayFixedBlockStateReader, StarknetResult};
use crate::rpc_objects::{
BlockHeader,
BlockId,
GetBlockWithTxHashesParams,
GetClassHashAtParams,
GetCompiledClassParams,
GetNonceParams,
Expand All @@ -37,7 +29,6 @@ use crate::rpc_objects::{
RPC_ERROR_CONTRACT_ADDRESS_NOT_FOUND,
RPC_ERROR_INVALID_PARAMS,
};
use crate::state_reader::{GatewayStateReaderWithCompiledClasses, StateReaderFactory};

#[derive(Clone)]
pub struct RpcStateReader {
Expand Down Expand Up @@ -171,78 +162,3 @@ impl BlockifierStateReader for RpcStateReader {
todo!()
}
}

pub struct RpcStateReaderFactory {
pub config: RpcStateReaderConfig,
}

impl FetchCompiledClasses for RpcStateReader {
fn get_compiled_classes(&self, _class_hash: ClassHash) -> StateResult<CompiledClasses> {
todo!()
}

fn is_declared(&self, _class_hash: ClassHash) -> StateResult<bool> {
todo!()
}
}

impl GatewayStateReaderWithCompiledClasses for RpcStateReader {}

// An alternative impl to get the synced state, not via the state-sync component. To be removed in
// the future.
#[async_trait]
impl GatewayFixedBlockStateReader for RpcStateReader {
async fn get_block_info(&self) -> StarknetResult<BlockInfo> {
let get_block_params = GetBlockWithTxHashesParams { block_id: self.block_id };
let reader = self.clone();

let get_block_with_tx_hashes_result = tokio::task::spawn_blocking(move || {
reader.send_rpc_request("starknet_getBlockWithTxHashes", get_block_params)
})
.await
.map_err(|e| StarknetError::internal_with_logging("JoinError", e))?
.map_err(|e| StarknetError::internal_with_logging("RPC error", e))?;

let block_header: BlockHeader = serde_json::from_value(get_block_with_tx_hashes_result)
.map_err(|e| StarknetError::internal_with_logging("Failed to parse block header", e))?;
let block_info = block_header.try_into().map_err(|e| {
StarknetError::internal_with_logging("Failed to convert block header to BlockInfo", e)
})?;
Ok(block_info)
}

async fn get_nonce(&self, contract_address: ContractAddress) -> StarknetResult<Nonce> {
let get_nonce_params = GetNonceParams { block_id: self.block_id, contract_address };
let reader = self.clone();
let result = tokio::task::spawn_blocking(move || {
reader.send_rpc_request("starknet_getNonce", get_nonce_params)
})
.await
.map_err(|e| StarknetError::internal_with_logging("JoinError", e))?;

match result {
Ok(value) => {
let nonce: Nonce = serde_json::from_value(value).map_err(|e| {
StarknetError::internal_with_logging("Failed to parse nonce", e)
})?;
Ok(nonce)
}
Err(RPCStateReaderError::ContractAddressNotFound(_)) => Ok(Nonce::default()),
Err(e) => Err(StarknetError::internal_with_logging("RPC error", e)),
}
}
}

#[async_trait]
impl StateReaderFactory for RpcStateReaderFactory {
async fn get_blockifier_state_reader_and_gateway_fixed_block_from_latest_block(
&self,
) -> StateSyncClientResult<(
Box<dyn GatewayStateReaderWithCompiledClasses>,
Box<dyn GatewayFixedBlockStateReader>,
)> {
let reader = RpcStateReader::from_latest(&self.config);
let fixed_client = RpcStateReader::from_latest(&self.config);
Ok((Box::new(reader), Box::new(fixed_client)))
}
}
55 changes: 0 additions & 55 deletions crates/apollo_gateway/src/rpc_state_reader_test.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,20 +1,15 @@
use apollo_gateway_config::config::RpcStateReaderConfig;
use apollo_rpc::CompiledContractClass;
use blockifier::blockifier::block::validated_gas_prices;
use blockifier::execution::contract_class::RunnableCompiledClass;
use blockifier::state::state_api::StateReader;
use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
use serde::Serialize;
use serde_json::json;
use starknet_api::block::{BlockInfo, BlockNumber, GasPricePerToken, StarknetVersion};
use starknet_api::contract_class::SierraVersion;
use starknet_api::{class_hash, contract_address, felt, nonce};

use crate::gateway_fixed_block_state_reader::GatewayFixedBlockStateReader;
use crate::rpc_objects::{
BlockHeader,
BlockId,
GetBlockWithTxHashesParams,
GetClassHashAtParams,
GetCompiledClassParams,
GetNonceParams,
Expand Down Expand Up @@ -50,56 +45,6 @@ fn mock_rpc_interaction(
.create()
}

#[tokio::test]
async fn test_get_block_info() {
let mut server = run_rpc_server().await;
let config = RpcStateReaderConfig { url: server.url(), ..Default::default() };

// GasPrice must be non-zero.
let l1_gas_price = GasPricePerToken { price_in_wei: 1_u8.into(), price_in_fri: 1_u8.into() };
let l1_data_gas_price =
GasPricePerToken { price_in_wei: 1_u8.into(), price_in_fri: 1_u8.into() };
let l2_gas_price = GasPricePerToken { price_in_wei: 1_u8.into(), price_in_fri: 1_u8.into() };
let gas_prices = validated_gas_prices(
l1_gas_price.price_in_wei.try_into().unwrap(),
l1_gas_price.price_in_fri.try_into().unwrap(),
l1_data_gas_price.price_in_wei.try_into().unwrap(),
l1_data_gas_price.price_in_fri.try_into().unwrap(),
l2_gas_price.price_in_wei.try_into().unwrap(),
l2_gas_price.price_in_fri.try_into().unwrap(),
);

let block_number = BlockNumber(100);
let starknet_version = StarknetVersion::LATEST;

let expected_result =
BlockInfo { block_number, gas_prices, starknet_version, ..Default::default() };

let mock = mock_rpc_interaction(
&mut server,
&config.json_rpc_version,
"starknet_getBlockWithTxHashes",
GetBlockWithTxHashesParams { block_id: BlockId::Latest },
&RpcResponse::Success(RpcSuccessResponse {
result: serde_json::to_value(BlockHeader {
block_number,
l1_gas_price,
l1_data_gas_price,
l2_gas_price,
starknet_version: starknet_version.to_string(),
..Default::default()
})
.unwrap(),
..Default::default()
}),
);

let client = RpcStateReader::from_latest(&config);
let result = client.get_block_info().await.unwrap();
assert_eq!(result, expected_result);
mock.assert_async().await;
}

#[tokio::test]
async fn test_get_storage_at() {
let mut server = run_rpc_server().await;
Expand Down