feat: added tx status, receipt and proof fetchers

Author: frolvanya

Cargo.toml

@@ -1,9 +1,9 @@
 [workspace]
 resolver = "3"
 members = ["api", "types"]
-rust-version = "1.85"
 
 [workspace.package]
+rust-version = "1.85"
 edition = "2024"
 version = "0.8.3"
 authors = [

api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "near-api"
-rust-version = "1.85"
+rust-version.workspace = true
 version.workspace = true
 authors.workspace = true
 license.workspace = true

api/examples/transaction_queries.rs

@@ -0,0 +1,58 @@
+use near_api::{
+    Chain, Transaction,
+    types::{AccountId, CryptoHash, Reference, TxExecutionStatus},
+};
+use testresult::TestResult;
+
+#[tokio::main]
+async fn main() -> TestResult {
+    let sender: AccountId = "omni.bridge.near".parse()?;
+    let tx_hash: CryptoHash = "GmvjRhbBwNCeekyZ4ezv43Zhs4U33kRTj6PRkFgKUKyJ".parse()?;
+
+    let status = Transaction::status(sender.clone(), tx_hash)
+        .fetch_from_mainnet()
+        .await?;
+    println!(
+        "[status] is_success={}, is_failure={}, gas_burnt={}",
+        status.is_success(),
+        status.is_failure(),
+        status.total_gas_burnt,
+    );
+
+    let status_final =
+        Transaction::status_with_options(sender.clone(), tx_hash, TxExecutionStatus::Final)
+            .fetch_from_mainnet()
+            .await?;
+    println!(
+        "[status_with_options(Final)] is_success={}, receipts={}",
+        status_final.is_success(),
+        status_final.receipt_outcomes().len(),
+    );
+
+    let receipt_id = status_final.outcome().receipt_ids[0];
+    let receipt = Transaction::receipt(receipt_id)
+        .fetch_from_mainnet()
+        .await?;
+    println!(
+        "[receipt] id={}, receiver={}, predecessor={}",
+        receipt.receipt_id, receipt.receiver_id, receipt.predecessor_id,
+    );
+
+    let head_hash = Chain::block_hash()
+        .at(Reference::Final)
+        .fetch_from_mainnet()
+        .await?;
+    let proof = Transaction::proof(sender, tx_hash, head_hash)
+        .fetch_from_mainnet()
+        .await?;
+    println!(
+        "[proof] outcome_proof_id={}, block_proof_len={}, outcome_root_proof_len={}",
+        proof.outcome_proof.id,
+        proof.block_proof.len(),
+        proof.outcome_root_proof.len(),
+    );
+
+    println!("\nAll transaction query methods passed!");
+
+    Ok(())
+}

api/src/common/query/handlers/mod.rs

@@ -1,17 +1,19 @@
 use borsh::BorshDeserialize;
 use near_api_types::{
     AccessKey, Account, AccountView, ContractCodeView, Data, PublicKey, RpcBlockResponse,
-    RpcValidatorResponse, ViewStateResult, json::U64,
+    RpcValidatorResponse, ViewStateResult, json::U64, transaction::result::ExecutionFinalResult,
+};
+use near_openapi_client::types::{
+    FinalExecutionOutcomeView, RpcQueryResponse, RpcReceiptResponse, RpcTransactionResponse,
 };
-use near_openapi_client::types::RpcQueryResponse;
 use serde::de::DeserializeOwned;
 use std::marker::PhantomData;
 use tracing::{info, trace, warn};
 
 use crate::{
     advanced::{
         RpcType, block_rpc::SimpleBlockRpc, query_rpc::SimpleQueryRpc,
-        validator_rpc::SimpleValidatorRpc,
+        tx_rpc::TransactionStatusRpc, validator_rpc::SimpleValidatorRpc,
     },
     common::query::{QUERY_EXECUTOR_TARGET, ResultWithMethod},
     errors::QueryError,
@@ -497,6 +499,93 @@ impl ResponseHandler for RpcBlockHandler {
     }
 }
 
+/// Handler that converts an [`RpcTransactionResponse`] into an [`ExecutionFinalResult`].
+///
+/// This reuses the same conversion logic from transaction sending: it extracts the
+/// `FinalExecutionOutcomeView` from the response and converts it using `TryFrom`.
+#[derive(Clone, Debug)]
+pub struct TransactionStatusHandler;
+
+impl ResponseHandler for TransactionStatusHandler {
+    type Response = ExecutionFinalResult;
+    type Query = TransactionStatusRpc;
+
+    fn process_response(
+        &self,
+        response: Vec<RpcTransactionResponse>,
+    ) -> ResultWithMethod<Self::Response, <Self::Query as RpcType>::Error> {
+        let response = response
+            .into_iter()
+            .next()
+            .ok_or(QueryError::InternalErrorNoResponse)?;
+
+        let final_execution_outcome_view = match response {
+            RpcTransactionResponse::Variant0 {
+                final_execution_status: _,
+                receipts: _,
+                receipts_outcome,
+                status,
+                transaction,
+                transaction_outcome,
+            } => FinalExecutionOutcomeView {
+                receipts_outcome,
+                status,
+                transaction,
+                transaction_outcome,
+            },
+            RpcTransactionResponse::Variant1 {
+                final_execution_status: _,
+                receipts_outcome,
+                status,
+                transaction,
+                transaction_outcome,
+            } => FinalExecutionOutcomeView {
+                receipts_outcome,
+                status,
+                transaction,
+                transaction_outcome,
+            },
+        };
+
+        info!(
+            target: QUERY_EXECUTOR_TARGET,
+            "Processed TransactionStatus response, tx hash: {:?}",
+            final_execution_outcome_view.transaction_outcome.id,
+        );
+
+        ExecutionFinalResult::try_from(final_execution_outcome_view)
+            .map_err(|e| QueryError::ConversionError(Box::new(e)))
+    }
+}
+
+/// Handler that passes through the raw [`RpcReceiptResponse`] without transformation.
+#[derive(Clone, Debug)]
+pub struct ReceiptHandler;
+
+impl ResponseHandler for ReceiptHandler {
+    type Response = RpcReceiptResponse;
+    type Query = crate::advanced::tx_rpc::ReceiptRpc;
+
+    fn process_response(
+        &self,
+        response: Vec<RpcReceiptResponse>,
+    ) -> ResultWithMethod<Self::Response, <Self::Query as RpcType>::Error> {
+        let response = response
+            .into_iter()
+            .next()
+            .ok_or(QueryError::InternalErrorNoResponse)?;
+
+        info!(
+            target: QUERY_EXECUTOR_TARGET,
+            "Processed Receipt response, receipt_id: {:?}, receiver: {:?}",
+            response.receipt_id,
+            response.receiver_id,
+        );
+
+        Ok(response)
+    }
+}
+
 impl<T: RpcType> ResponseHandler for T {
     type Response = <T as RpcType>::Response;
     type Query = T;

api/src/common/query/mod.rs

@@ -14,6 +14,7 @@ pub mod block_rpc;
 pub mod handlers;
 pub mod query_request;
 pub mod query_rpc;
+pub mod tx_rpc;
 pub mod validator_rpc;
 
 pub use handlers::*;