feat(rpc/v06): re-add execution methods

crates/rpc/src/dto/simulation.rs

@@ -30,7 +30,10 @@ impl crate::dto::SerializeForVersion for TransactionTrace {
                 if self.include_state_diff {
                     serializer.serialize_field("state_diff", &trace.state_diff)?;
                 }
-                serializer.serialize_field("execution_resources", &trace.execution_resources)?;
+                if serializer.version > RpcVersion::V06 {
+                    serializer
+                        .serialize_field("execution_resources", &trace.execution_resources)?;
+                }
             }
             pathfinder_executor::types::TransactionTrace::DeployAccount(trace) => {
                 serializer.serialize_field("type", &"DEPLOY_ACCOUNT")?;
@@ -50,7 +53,10 @@ impl crate::dto::SerializeForVersion for TransactionTrace {
                 if self.include_state_diff {
                     serializer.serialize_field("state_diff", &trace.state_diff)?;
                 }
-                serializer.serialize_field("execution_resources", &trace.execution_resources)?;
+                if serializer.version > RpcVersion::V06 {
+                    serializer
+                        .serialize_field("execution_resources", &trace.execution_resources)?;
+                }
             }
             pathfinder_executor::types::TransactionTrace::Invoke(trace) => {
                 serializer.serialize_field("type", &"INVOKE")?;
@@ -65,7 +71,10 @@ impl crate::dto::SerializeForVersion for TransactionTrace {
                 if self.include_state_diff {
                     serializer.serialize_field("state_diff", &trace.state_diff)?;
                 }
-                serializer.serialize_field("execution_resources", &trace.execution_resources)?;
+                if serializer.version > RpcVersion::V06 {
+                    serializer
+                        .serialize_field("execution_resources", &trace.execution_resources)?;
+                }
             }
             pathfinder_executor::types::TransactionTrace::L1Handler(trace) => {
                 serializer.serialize_field("type", &"L1_HANDLER")?;
@@ -78,7 +87,10 @@ impl crate::dto::SerializeForVersion for TransactionTrace {
                 if self.include_state_diff {
                     serializer.serialize_field("state_diff", &trace.state_diff)?;
                 }
-                serializer.serialize_field("execution_resources", &trace.execution_resources)?;
+                if serializer.version > RpcVersion::V06 {
+                    serializer
+                        .serialize_field("execution_resources", &trace.execution_resources)?;
+                }
             }
         }
         serializer.end()

crates/rpc/src/error.rs

@@ -120,14 +120,20 @@ pub enum ApplicationError {
 }
 
 impl ApplicationError {
-    pub fn code(&self) -> i32 {
+    pub fn code(&self, version: RpcVersion) -> i32 {
         match self {
             // Taken from the official starknet json rpc api.
             // https://github.com/starkware-libs/starknet-specs
             ApplicationError::FailedToReceiveTxn => 1,
             ApplicationError::NoTraceAvailable(_) => 10,
             ApplicationError::ContractNotFound => 20,
-            ApplicationError::EntrypointNotFound => 21,
+            ApplicationError::EntrypointNotFound => {
+                if version >= RpcVersion::V08 {
+                    21
+                } else {
+                    -32603 /* Custom - new code not available */
+                }
+            }
             ApplicationError::BlockNotFound => 24,
             ApplicationError::InvalidTxnHash => 25,
             ApplicationError::InvalidBlockHash => 26,
@@ -173,9 +179,17 @@ impl ApplicationError {
 
     pub fn message(&self, version: RpcVersion) -> String {
         match self {
+            ApplicationError::EntrypointNotFound => {
+                if version >= RpcVersion::V08 {
+                    self.to_string()
+                } else {
+                    "Invalid message selector".to_string()
+                }
+            }
             ApplicationError::InsufficientResourcesForValidate => match version {
-                RpcVersion::V07 => "Max fee is smaller than the minimal transaction cost \
-                                    (validation plus fee transfer)"
+                RpcVersion::V06 | RpcVersion::V07 => "Max fee is smaller than the minimal \
+                                                      transaction cost (validation plus fee \
+                                                      transfer)"
                     .to_string(),
                 _ => self.to_string(),
             },
@@ -207,7 +221,7 @@ impl ApplicationError {
             ApplicationError::InsufficientAccountBalance => None,
             ApplicationError::ValidationFailure => None,
             ApplicationError::CompilationFailed { data } => match version {
-                RpcVersion::V07 => None,
+                RpcVersion::V06 | RpcVersion::V07 => None,
                 _ => Some(json!(data)),
             },
             ApplicationError::ContractClassSizeIsTooLarge => None,

crates/rpc/src/jsonrpc/error.rs

@@ -28,15 +28,15 @@ impl PartialEq for RpcError {
 }
 
 impl RpcError {
-    pub fn code(&self) -> i32 {
+    pub fn code(&self, version: RpcVersion) -> i32 {
         // From the json-rpc specification: https://www.jsonrpc.org/specification#error_object
         match self {
             RpcError::ParseError(..) => -32700,
             RpcError::InvalidRequest(..) => -32600,
             RpcError::MethodNotFound { .. } => -32601,
             RpcError::InvalidParams(..) => -32602,
             RpcError::InternalError(_) => -32603,
-            RpcError::ApplicationError(err) => err.code(),
+            RpcError::ApplicationError(err) => err.code(version),
             RpcError::WebsocketSubscriptionClosed { .. } => -32099,
         }
     }
@@ -80,7 +80,7 @@ impl crate::dto::SerializeForVersion for RpcError {
         serializer: crate::dto::Serializer,
     ) -> Result<crate::dto::Ok, crate::dto::Error> {
         let mut obj = serializer.serialize_struct()?;
-        obj.serialize_field("code", &self.code())?;
+        obj.serialize_field("code", &self.code(serializer.version))?;
         obj.serialize_field("message", &self.message(serializer.version).as_ref())?;
 
         if let Some(data) = self.data(serializer.version) {

crates/rpc/src/jsonrpc/response.rs

@@ -155,7 +155,7 @@ mod tests {
         let expected = json!({
             "jsonrpc": "2.0",
             "error": {
-                "code": parsing_err.code(),
+                "code": parsing_err.code(RpcVersion::V07),
                 "message": parsing_err.message(RpcVersion::V07),
                 "data": parsing_err.data(RpcVersion::V07),
             },

crates/rpc/src/lib.rs

@@ -972,18 +972,13 @@ mod tests {
             "starknet_estimateFee",
             "starknet_estimateMessageFee",
             "starknet_getEvents",
-            "starknet_call",
         ],
         Api::HttpOnly)]
     // #[case::v0_6_api_websocket("/ws/rpc/v0_6", "v06/starknet_api_openrpc.json", &[], Api::WebsocketOnly)]
     #[case::v0_6_trace(
         "/rpc/v0_6",
         "v06/starknet_trace_api_openrpc.json",
-        &[
-            "starknet_traceTransaction",
-            "starknet_simulateTransactions",
-            "starknet_traceBlockTransactions",
-        ],
+        &[],
         Api::HttpOnly)]
     // #[case::v0_6_trace_websocket("/ws/rpc/v0_6", "v06/starknet_trace_api_openrpc.json", &[], Api::WebsocketOnly)]
     #[case::v0_6_write("/rpc/v0_6", "v06/starknet_write_api.json", &[], Api::HttpOnly)]

crates/rpc/src/v06.rs

@@ -8,6 +8,7 @@ pub fn register_routes() -> RpcRouterBuilder {
         .register("starknet_addInvokeTransaction",                crate::method::add_invoke_transaction)
         .register("starknet_blockNumber",                         crate::method::block_number)
         .register("starknet_blockHashAndNumber",                  crate::method::block_hash_and_number)
+        .register("starknet_call",                                crate::method::call)
         .register("starknet_chainId",                             crate::method::chain_id)
         .register("starknet_getClass",                            crate::method::get_class)
         .register("starknet_getClassAt",                          crate::method::get_class_at)
@@ -19,7 +20,10 @@ pub fn register_routes() -> RpcRouterBuilder {
         .register("starknet_getStorageAt",                        crate::method::get_storage_at)
         .register("starknet_getTransactionByHash",                crate::method::get_transaction_by_hash)
         .register("starknet_getTransactionByBlockIdAndIndex",     crate::method::get_transaction_by_block_id_and_index)
+        .register("starknet_simulateTransactions",                crate::method::simulate_transactions)
         .register("starknet_specVersion",                         || "0.6.0")
         .register("starknet_syncing",                             crate::method::syncing)
+        .register("starknet_traceBlockTransactions",              crate::method::trace_block_transactions)
+        .register("starknet_traceTransaction",                    crate::method::trace_transaction)
         .register("pathfinder_getProof",                          crate::pathfinder::methods::get_proof)
 }