refactor(probe): enforce the absence meaning on the trait

`ClassifyRpcOutcome::Response` now requires `HasAbsenceMeaning`, so a
transport cannot classify a response type that never declared what a
"not found" answer means for it.

Also restores the `#[from]` conversions on `AptosRpcError` and sweeps the
comments this stack added.

Author: haiyuechen-nearone

crates/foreign-chain-inspector/src/aptos/inspector.rs

@@ -104,7 +104,7 @@ impl HasAbsenceMeaning for TransactionResponse {
     const ABSENCE: AbsenceMeaning = AbsenceMeaning::TransactionIsAbsent;
 }
 
-/// The ledger info is the REST API root, which every Aptos node serves.
+/// Every Aptos node serves the ledger info at its REST API base.
 impl HasAbsenceMeaning for LedgerInfoResponse {
     const ABSENCE: AbsenceMeaning = AbsenceMeaning::ApiIsNotServed;
 }
@@ -137,8 +137,7 @@ impl<T: HasAbsenceMeaning> ClassifyRpcOutcome for Result<T, AptosRpcError> {
             AptosRpcError::ApiError { status, .. } if status >= 500 => {
                 ForeignChainInspectionError::RpcRequestFailed(message)
             }
-            // Remaining 4xx (400/401/403/410, …) are deterministic rejections —
-            // retrying cannot change them, so they count as substantive verdicts.
+            // Retrying cannot change a deterministic 4xx, so it counts as a substantive verdict.
             AptosRpcError::ApiError { .. } => {
                 ForeignChainInspectionError::RpcRequestRejected(message)
             }
@@ -292,7 +291,6 @@ mod tests {
     };
     use rstest::rstest;
 
-    /// Mainnet, as the docs and the config templates ship it.
     const MAINNET_CHAIN_ID: u64 = 1;
 
     struct MockAptosClient {
@@ -878,7 +876,7 @@ mod tests {
     #[case::internal_error(500)]
     #[case::bad_request(400)]
     #[case::unauthorized(401)]
-    fn classified__should_read_every_status_but_404_alike(#[case] status: u16) {
+    fn classified__should_treat_404_as_the_only_resource_dependent_status(#[case] status: u16) {
         // Given
         let read_as_transaction: Result<TransactionResponse, _> =
             Err(MockAptosClient::error(status));

crates/foreign-chain-inspector/src/lib.rs

@@ -470,27 +470,23 @@ fn is_retryable_status(status_code: u16) -> bool {
     matches!(status_code, REQUEST_TIMEOUT | TOO_MANY_REQUESTS) || status_code >= SERVER_ERROR
 }
 
-/// What a provider's "not found" answer means for the resource that was read: the one wire
-/// condition whose verdict depends on what was asked for rather than on the status itself.
+/// The meaning of a provider's "not found" answer
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum AbsenceMeaning {
-    /// The chain may legitimately not hold it.
     TransactionIsAbsent,
-    /// Every node serving this chain's API holds it.
     ApiIsNotServed,
 }
 
 /// The [`AbsenceMeaning`] of the resource a response carries. Required by
-/// [`ClassifyRpcOutcome::classified`], so a response that never answered cannot be classified.
+/// [`ClassifyRpcOutcome::classified`], so an undeclared response type cannot be classified.
 pub(crate) trait HasAbsenceMeaning {
     const ABSENCE: AbsenceMeaning;
 }
 
-/// Reads a chain client's outcome as an inspection outcome: the response type supplies what
-/// absence means, so the call site supplies nothing. One implementation per transport, each
-/// holding that chain's status table.
+/// Reads a chain client's outcome as an inspection outcome. The absence meaning comes from the
+/// response type.
 pub(crate) trait ClassifyRpcOutcome {
-    type Response;
+    type Response: HasAbsenceMeaning;
 
     fn classified(self) -> Result<Self::Response, ForeignChainInspectionError>;
 }

crates/foreign-chain-inspector/tests/aptos_inspector.rs

@@ -211,7 +211,7 @@ async fn extract__should_classify_http_errors_by_status(
 
 #[tokio::test]
 async fn extract__should_reject_a_response_that_does_not_carry_the_resource() {
-    // Given — a URL that answers but serves something other than the Aptos REST API.
+    // Given
     let server = MockServer::start();
     server.mock(|when, then| {
         when.method(GET).path(tx_path());
@@ -226,7 +226,7 @@ async fn extract__should_reject_a_response_that_does_not_carry_the_resource() {
         .extract(tx_id(), AptosFinality::Committed, vec![])
         .await;
 
-    // Then — the endpoint is wrong, not slow, so retrying it cannot help.
+    // Then
     let error = response.expect_err("extract should fail");
     assert_matches!(error, ForeignChainInspectionError::MalformedRpcResponse(_));
     assert!(!error.is_transient());

crates/foreign-chain-rpc-interfaces/src/aptos.rs

@@ -44,11 +44,11 @@ pub struct EventGuid {
 #[derive(Debug, thiserror::Error)]
 pub enum AptosRpcError {
     #[error("HTTP request failed: {0}")]
-    Http(reqwest::Error),
+    Http(#[from] reqwest::Error),
     #[error("Aptos API returned HTTP {status}: {body}")]
     ApiError { status: u16, body: String },
     #[error("failed to decode the Aptos API response: {0}")]
-    MalformedBody(serde_json::Error),
+    MalformedBody(#[from] serde_json::Error),
 }
 
 /// Partial response of the API root: the ledger info every Aptos node reports.
@@ -110,12 +110,7 @@ impl ReqwestAptosClient {
     }
 
     async fn get_json<T: DeserializeOwned>(&self, url: Url) -> Result<T, AptosRpcError> {
-        let response = self
-            .client
-            .get(url)
-            .send()
-            .await
-            .map_err(AptosRpcError::Http)?;
+        let response = self.client.get(url).send().await?;
         let status = response.status();
         if !status.is_success() {
             let body = response.text().await.unwrap_or_default();
@@ -125,8 +120,8 @@ impl ReqwestAptosClient {
             });
         }
 
-        let body = response.bytes().await.map_err(AptosRpcError::Http)?;
-        serde_json::from_slice(&body).map_err(AptosRpcError::MalformedBody)
+        let body = response.bytes().await?;
+        Ok(serde_json::from_slice(&body)?)
     }
 }