starknet_transaction_prover: add exhaustive error enum and error mapping tests

Add SpecErrorKind enum to make spec error coverage compiler-enforced:
adding a new error to the spec requires adding a variant, or the match
is non-exhaustive. Refactor rpc_spec_test to use SpecErrorKind::ALL.

Add 7 error code verification tests covering all RPC error code paths.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: avi-starkware

crates/starknet_transaction_prover/src/server/errors.rs

@@ -16,6 +16,58 @@ use jsonrpsee::types::ErrorObjectOwned;
 
 use crate::errors::{RunnerError, VirtualBlockExecutorError, VirtualSnosProverError};
 
+// --- Test-only: exhaustive spec error enum ---
+
+/// Every error defined in the OpenRPC spec (`components/errors`).
+///
+/// Adding a new error to the spec requires adding a variant here; the compiler enforces
+/// exhaustive coverage via `SpecErrorKind::ALL` in the spec test.
+#[cfg(test)]
+#[derive(Clone, Copy)]
+pub(crate) enum SpecErrorKind {
+    BlockNotFound,
+    AccountValidationFailed,
+    UnsupportedTxVersion,
+    ServiceBusy,
+    InvalidTransactionInput,
+}
+
+#[cfg(test)]
+impl SpecErrorKind {
+    /// All variants — used by the spec completeness test.
+    pub(crate) const ALL: &[Self] = &[
+        Self::BlockNotFound,
+        Self::AccountValidationFailed,
+        Self::UnsupportedTxVersion,
+        Self::ServiceBusy,
+        Self::InvalidTransactionInput,
+    ];
+
+    /// The key in `components/errors` of the OpenRPC spec.
+    pub(crate) fn spec_key(self) -> &'static str {
+        match self {
+            Self::BlockNotFound => "BLOCK_NOT_FOUND",
+            Self::AccountValidationFailed => "ACCOUNT_VALIDATION_FAILED",
+            Self::UnsupportedTxVersion => "UNSUPPORTED_TX_VERSION",
+            Self::ServiceBusy => "SERVICE_BUSY",
+            Self::InvalidTransactionInput => "INVALID_TRANSACTION_INPUT",
+        }
+    }
+
+    /// A representative `ErrorObjectOwned` for this error kind.
+    pub(crate) fn example_error(self) -> jsonrpsee::types::ErrorObjectOwned {
+        match self {
+            Self::BlockNotFound => block_not_found(),
+            Self::AccountValidationFailed => validation_failure("test".to_string()),
+            Self::UnsupportedTxVersion => unsupported_tx_version("v99".to_string()),
+            Self::ServiceBusy => service_busy(2),
+            Self::InvalidTransactionInput => {
+                invalid_transaction_input("test field invalid".to_string())
+            }
+        }
+    }
+}
+
 // Starknet RPC v0.10 error codes.
 
 /// Block not found (code 24).

crates/starknet_transaction_prover/src/server/errors_test.rs

@@ -9,14 +9,19 @@ use crate::errors::{
     VirtualBlockExecutorError,
     VirtualSnosProverError,
 };
-use crate::server::errors::internal_server_error;
+use crate::server::errors::{internal_server_error, service_busy};
 
 fn error_data(err: VirtualSnosProverError) -> String {
     let rpc_err: jsonrpsee::types::ErrorObjectOwned = err.into();
     let raw_value = rpc_err.data().expect("expected error data to be present");
     serde_json::from_str(raw_value.get()).expect("error data should be valid JSON string")
 }
 
+fn error_code(err: VirtualSnosProverError) -> i32 {
+    let rpc_err: jsonrpsee::types::ErrorObjectOwned = err.into();
+    rpc_err.code()
+}
+
 #[test]
 fn test_transaction_reverted_produces_user_friendly_message() {
     let tx_hash = TransactionHash(felt!("0x123"));
@@ -122,3 +127,73 @@ fn test_internal_server_error_has_data_field() {
     let rpc_err = internal_server_error("some detail");
     assert!(rpc_err.data().is_some(), "internal_server_error should always include a data field");
 }
+
+#[test]
+fn test_invalid_transaction_type_produces_unsupported_tx_version() {
+    let err = VirtualSnosProverError::InvalidTransactionType("unsupported version".to_string());
+    let rpc_err: jsonrpsee::types::ErrorObjectOwned = err.into();
+
+    assert_eq!(rpc_err.code(), 61);
+    assert_eq!(rpc_err.message(), "The transaction version is not supported");
+}
+
+#[test]
+fn test_invalid_transaction_input_produces_code_1000() {
+    let err = VirtualSnosProverError::InvalidTransactionInput("bad input".to_string());
+    let rpc_err: jsonrpsee::types::ErrorObjectOwned = err.into();
+
+    assert_eq!(rpc_err.code(), 1000);
+    assert_eq!(rpc_err.message(), "Invalid transaction input");
+}
+
+#[test]
+fn test_pending_block_validation_error_produces_block_not_found() {
+    let err = VirtualSnosProverError::ValidationError(
+        "Pending blocks are not supported in this context".to_string(),
+    );
+    let rpc_err: jsonrpsee::types::ErrorObjectOwned = err.into();
+
+    assert_eq!(rpc_err.code(), 24);
+    assert_eq!(rpc_err.message(), "Block not found");
+}
+
+#[test]
+fn test_non_pending_validation_error_produces_validation_failure() {
+    let err = VirtualSnosProverError::ValidationError("some other validation error".to_string());
+    let rpc_err: jsonrpsee::types::ErrorObjectOwned = err.into();
+
+    assert_eq!(rpc_err.code(), 55);
+    assert_eq!(rpc_err.message(), "Account validation failed");
+}
+
+#[test]
+fn test_bouncer_lock_error_produces_internal_error() {
+    let inner = VirtualBlockExecutorError::BouncerLockError("lock poisoned".to_string());
+    let err = VirtualSnosProverError::from(Box::new(RunnerError::from(inner)));
+
+    // Internal error code is -32603.
+    assert_eq!(error_code(err), -32603);
+}
+
+#[test]
+fn test_reexecution_error_produces_internal_error() {
+    use blockifier_reexecution::errors::ReexecutionError;
+    let inner = VirtualBlockExecutorError::ReexecutionError(Box::new(
+        ReexecutionError::AmbiguousChainIdFromUrl("http://example.com".to_string()),
+    ));
+    let err = VirtualSnosProverError::from(Box::new(RunnerError::from(inner)));
+
+    assert_eq!(error_code(err), -32603);
+}
+
+#[test]
+fn test_service_busy_has_correct_code_and_message() {
+    let rpc_err = service_busy(2);
+
+    assert_eq!(rpc_err.code(), -32005);
+    assert_eq!(rpc_err.message(), "Service is busy");
+    let raw_value = rpc_err.data().expect("service_busy should include a data field");
+    let data: String =
+        serde_json::from_str(raw_value.get()).expect("data should be a valid JSON string");
+    assert!(data.contains("2 concurrent"), "Expected '2 concurrent' in: {data}");
+}

crates/starknet_transaction_prover/src/server/rpc_spec_test.rs

@@ -24,7 +24,6 @@ use starknet_types_core::felt::Felt;
 
 use crate::config::ProverConfig;
 use crate::proving::virtual_snos_prover::RpcVirtualSnosProver;
-use crate::server::errors;
 use crate::server::mock_rpc::MockProvingRpc;
 use crate::server::rpc_api::ProvingRpcServer;
 use crate::server::rpc_impl::ProvingRpcServerImpl;
@@ -288,26 +287,19 @@ async fn test_prove_transaction_rejects_pending_block_id(
 }
 
 #[test]
-// TODO(Avi): Add an error enum to make this test exhastive.
 fn test_error_responses_match_spec() {
-    let test_cases: Vec<(&str, ErrorObjectOwned)> = vec![
-        ("BLOCK_NOT_FOUND", errors::block_not_found()),
-        ("ACCOUNT_VALIDATION_FAILED", errors::validation_failure("test".to_string())),
-        ("UNSUPPORTED_TX_VERSION", errors::unsupported_tx_version("v99".to_string())),
-        ("SERVICE_BUSY", errors::service_busy(2)),
-        (
-            "INVALID_TRANSACTION_INPUT",
-            errors::invalid_transaction_input("test field invalid".to_string()),
-        ),
-    ];
+    use crate::server::errors::SpecErrorKind;
+
+    let test_cases: Vec<(&str, ErrorObjectOwned)> =
+        SpecErrorKind::ALL.iter().map(|kind| (kind.spec_key(), kind.example_error())).collect();
 
     // Completeness guard: ensure all spec errors have a test case.
     let spec_error_keys: HashSet<&str> =
         SPEC["components"]["errors"].as_object().unwrap().keys().map(|k| k.as_str()).collect();
     let tested_error_keys: HashSet<&str> = test_cases.iter().map(|(key, _)| *key).collect();
     assert_eq!(
         tested_error_keys, spec_error_keys,
-        "Test cases don't cover all spec errors. Update the test_cases list above."
+        "Test cases don't cover all spec errors. Add a variant to SpecErrorKind."
     );
 
     for (spec_key, actual) in &test_cases {