fix(sequencer): structured JSON errors for skipped transactions

[0xtristan]

Summary

When a transaction is skipped (e.g. due to a bad generation number or nonce), the sequencer was serializing the TransactionReceipt using format!("{:?}", receipt) — a Rust debug string stuffed into a JSON field. This made it impossible for SDK clients to deserialize the error in a structured way; they had to regex-match an opaque string.

TransactionReceipt, SkippedTxContents, and TxProcessingError all already derived serde::Serialize, so the fix was straightforward.

Commit 1 — serialize receipt as JSON

Replaces format!("{:?}", receipt) with serde_json::to_value(&receipt) in the UnsuccessfulTransaction arm of block_executor.rs. The Reverted case already handled this correctly; the Skipped/Ignored cases did not.

Commit 2 — CheckUniquenessError typed enum

TxProcessingError::CheckUniquenessFailed(String) gave clients no machine-readable way to identify the failure type or extract fields. This replaces the String with a proper enum:

pub enum CheckUniquenessError {
    BadGeneration { latest_generation: u64, provided_generation: u64 },
    DuplicateGeneration { generation: u64 },
    GenerationCapacityExceeded { current_generation: u64, next_valid_generation: u64 },
    BadNonce { expected_nonce: u64, provided_nonce: u64 },
    NonceTooLow { minimum_nonce: u64, provided_nonce: u64 },
    Internal(String), // state-access failures
}

The enum uses #[serde(tag = "kind", rename_all = "snake_case")] so the JSON output is fully typed:

{"kind": "bad_generation", "latest_generation": 1778774165791000, "provided_generation": 1778806984782}

The change threads through: generations.rs / nonces.rs → Uniqueness::check_uniqueness → TransactionAuthorizer trait → StandardProvenRollupCapabilities → registered.rs / unregistered.rs. All test assertions are updated to match on variant fields rather than substrings.

Test plan

• Existing uniqueness integration tests pass (sov-uniqueness)
• nonce_buffer_task tests pass
• tx_revert_tests pass
• Verify JSON error response shape from a live sequencer for a bad-generation tx

🤖 Generated with Claude Code

[github-actions]

Thank you for your submission, we really appreciate it. Like many open-source projects, we ask that you sign our Contributor License Agreement before we can accept your contribution. You can sign the CLA by just posting a Pull Request Comment same as the below format.

---

I have read the CLA Document and I hereby sign the CLA

---

_{You can retrigger this bot by commenting recheck in this Pull Request. Posted by the CLA Assistant Lite bot.}

[ross-weir]

Lets impl ErrorDetail on TxProcessingError & CheckUniquenessError, then here we do something similar to reverted:

  sov_rollup_interface::stf::TxEffect::Skipped(skipped) => {
      skipped.error.error_detail().unwrap_or(json_obj!({}))
  }

In the impl on TxProcessingError for the CheckUniquenessFailed variant we delegate to inner.error_detail() for all other variants fall back to json_obj!({"error": format!("{:?}", receipt)})

Then we have everything in place to gradually migrate the other variants on TxProcessingError to structured errors

[ross-weir]

Would it be possible to include a reason field on the error here so we can supply InvalidNonceReason? That enum provides a lot of useful context for exactly why the nonce is bad

[ross-weir]

Would it be possible to define this closer to the uniqueness code? This file contains more higher level tx receipt types

Also we should impl ErrorDetail for it, which I think could jsut be:

impl ErrorDetail for CheckUniquenessError {
    fn error_detail(&self) -> Result<ErrorContext, Box<dyn std::error::Error + Send + Sync>> {
        Ok(err_detail!(self))
    }
}

[ross-weir]

We have a CoreModuleError type that we can use for state accessor errors, so this becomes:

.map_err(CoreModuleError::state_read)?

And we add a CoreModuleError variant to CheckUniquenessError - see bank Error impl for example of how it's used