RPC version 0.4.0

Cargo.toml

@@ -51,12 +51,12 @@ anyhow = "1"
 # Starknet dependencies
 starknet_api = { version = "0.3.0", features = ["testing"] }
 starknet-in-rust = { git = "https://github.com/lambdaclass/starknet_in_rust", rev = "f05da40", package="starknet_in_rust" }
-starknet-rs-signers = { version = "0.3.0", package = "starknet-signers" }
+starknet-rs-signers = { version = "0.4.0", package="starknet-signers" }
 starknet-rs-ff = { version = "0.3.4", package = "starknet-ff" }
-starknet-rs-core = { version = "0.5.1", package = "starknet-core" }
-starknet-rs-providers = { version = "0.5.0", package = "starknet-providers" }
-starknet-rs-accounts = { version = "0.4.0", package = "starknet-accounts" }
-starknet-rs-contract = { version = "0.4.0", package = "starknet-contract" }
+starknet-rs-core = {  version = "0.6.0", package = "starknet-core" }
+starknet-rs-providers = {  version = "0.6.0", package = "starknet-providers" }
+starknet-rs-accounts = { version = "0.5.0", package = "starknet-accounts" }
+starknet-rs-contract = { version = "0.5.0", package = "starknet-contract" }
 cairo-felt = { version = "0.8.5", package = "cairo-felt" }
 url = "2.4"
 

crates/starknet-server/Cargo.toml

@@ -52,3 +52,4 @@ lazy_static = { workspace = true }
 starknet-rs-accounts = { workspace = true }
 starknet-rs-contract = { workspace = true }
 starknet-rs-signers = { workspace = true }
+starknet-core = { workspace = true, features = ["test_utils"] }

crates/starknet-server/src/api/json_rpc/endpoints.rs

@@ -2,26 +2,27 @@ use starknet_core::error::Error;
 use starknet_in_rust::core::errors::state_errors::StateError;
 use starknet_in_rust::transaction::error::TransactionError;
 use starknet_in_rust::utils::Address;
-use starknet_rs_core::types::ContractClass as CodegenContractClass;
+use starknet_rs_core::types::{ContractClass as CodegenContractClass, MsgFromL1};
 use starknet_types::contract_address::ContractAddress;
 use starknet_types::felt::{ClassHash, Felt, TransactionHash};
-use starknet_types::rpc::block::{Block, BlockHeader};
+use starknet_types::rpc::block::{Block, BlockHeader, BlockId};
+use starknet_types::rpc::estimate_message_fee::FeeEstimateWrapper;
+use starknet_types::rpc::transaction_receipt::TransactionReceipt;
 use starknet_types::rpc::transactions::{
     BroadcastedTransaction, EventFilter, EventsChunk, FunctionCall, Transaction,
-    TransactionReceiptWithStatus,
 };
 use starknet_types::starknet_api::block::BlockNumber;
 use starknet_types::traits::ToHexString;
 
 use super::error::ApiError;
-use super::models::{BlockHashAndNumberOutput, EstimateFeeOutput, SyncingOutput};
+use super::models::{BlockHashAndNumberOutput, SyncingOutput};
 use super::JsonRpcHandler;
 use crate::api::json_rpc::error::RpcResult;
 use crate::api::models::state::{
     ClassHashes, ContractNonce, DeployedContract, StateUpdate, StorageDiff, StorageEntry,
     ThinStateDiff,
 };
-use crate::api::models::{BlockId, PatriciaKeyHex};
+use crate::api::models::PatriciaKeyHex;
 
 const DEFAULT_CONTINUATION_TOKEN: &str = "0";
 
@@ -168,7 +169,7 @@ impl JsonRpcHandler {
     pub(crate) async fn get_transaction_receipt_by_hash(
         &self,
         transaction_hash: TransactionHash,
-    ) -> RpcResult<TransactionReceiptWithStatus> {
+    ) -> RpcResult<TransactionReceipt> {
         match self.api.starknet.read().await.get_transaction_receipt_by_hash(transaction_hash) {
             Ok(receipt) => Ok(receipt),
             Err(Error::NoTransaction) => Err(ApiError::TransactionNotFound),
@@ -266,18 +267,25 @@ impl JsonRpcHandler {
         &self,
         block_id: BlockId,
         request: Vec<BroadcastedTransaction>,
-    ) -> RpcResult<Vec<EstimateFeeOutput>> {
-        // TODO: move EstimateFeeOutput to types
+    ) -> RpcResult<Vec<FeeEstimateWrapper>> {
         let starknet = self.api.starknet.read().await;
-        match starknet.estimate_gas_usage(block_id.into(), &request) {
-            Ok(result) => Ok(result
-                .iter()
-                .map(|gas_consumed| EstimateFeeOutput {
-                    gas_consumed: format!("0x{gas_consumed:x}"),
-                    gas_price: format!("0x{:x}", starknet.config.gas_price),
-                    overall_fee: format!("0x{:x}", starknet.config.gas_price * gas_consumed),
-                })
-                .collect()),
+        match starknet.estimate_fee(block_id.into(), &request) {
+            Ok(result) => Ok(result),
+            Err(Error::ContractNotFound) => Err(ApiError::ContractNotFound),
+            Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
+            Err(err) => Err(ApiError::ContractError { msg: err.to_string() }),
+        }
+    }
+
+    pub(crate) async fn estimate_message_fee(
+        &self,
+        block_id: BlockId,
+        message: MsgFromL1,
+    ) -> RpcResult<FeeEstimateWrapper> {
+        match self.api.starknet.read().await.estimate_message_fee(block_id.into(), message) {
+            Ok(result) => Ok(result),
+            Err(Error::ContractNotFound) => Err(ApiError::ContractNotFound),
+            Err(Error::NoBlock) => Err(ApiError::BlockNotFound),
             Err(err) => Err(ApiError::ContractError { msg: err.to_string() }),
         }
     }

crates/starknet-server/src/api/json_rpc/error.rs

@@ -64,7 +64,7 @@ mod tests {
     fn transaction_not_found_error() {
         error_expected_code_and_message(
             ApiError::TransactionNotFound,
-            25,
+            29,
             "Transaction hash not found",
         );
     }

crates/starknet-server/src/api/json_rpc/mod.rs

@@ -12,6 +12,7 @@ use serde::{Deserialize, Serialize};
 use server::rpc_core::error::RpcError;
 use server::rpc_core::response::ResponseResult;
 use server::rpc_handler::RpcHandler;
+use starknet_types::rpc::estimate_message_fee::EstimateMessageFeeRequestWrapper;
 use tracing::{error, info, trace};
 
 use self::error::ApiError;
@@ -58,7 +59,7 @@ impl<T: Serialize> ToRpcResponseResult for RpcResult<T> {
                     data: None,
                 },
                 err @ ApiError::TransactionNotFound => RpcError {
-                    code: server::rpc_core::error::ErrorCode::ServerError(25),
+                    code: server::rpc_core::error::ErrorCode::ServerError(29),
                     message: err.to_string().into(),
                     data: None,
                 },
@@ -226,11 +227,15 @@ impl JsonRpcHandler {
             StarknetRequest::AddInvokeTransaction(BroadcastedInvokeTransactionInput {
                 invoke_transaction,
             }) => self.add_invoke_transaction(invoke_transaction).await.to_rpc_result(),
+            StarknetRequest::EstimateMessageFee(request) => self
+                .estimate_message_fee(request.get_block_id(), request.get_raw_message().clone())
+                .await
+                .to_rpc_result(),
         }
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Deserialize, Eq)]
+#[derive(Clone, Debug, Deserialize)]
 #[serde(tag = "method", content = "params")]
 pub enum StarknetRequest {
     #[serde(rename = "starknet_getBlockWithTxHashes")]
@@ -279,6 +284,8 @@ pub enum StarknetRequest {
     AddDeployAccountTransaction(BroadcastedDeployAccountTransactionInput),
     #[serde(rename = "starknet_addInvokeTransaction")]
     AddInvokeTransaction(BroadcastedInvokeTransactionInput),
+    #[serde(rename = "starknet_estimateMessageFee")]
+    EstimateMessageFee(EstimateMessageFeeRequestWrapper),
 }
 
 impl std::fmt::Display for StarknetRequest {
@@ -319,6 +326,7 @@ impl std::fmt::Display for StarknetRequest {
                 write!(f, "starknet_addDeployAccountTransaction")
             }
             StarknetRequest::AddInvokeTransaction(_) => write!(f, "starknet_addInvokeTransaction"),
+            StarknetRequest::EstimateMessageFee(_) => write!(f, "starknet_estimateMessageFee"),
         }
     }
 }