feat(core): Enhance block retrieval with configuration support (#218)

Author: BretasArthur1

crates/core/src/error.rs

@@ -4,8 +4,9 @@ use crossbeam_channel::TrySendError;
 use jsonrpc_core::{Error, Result};
 use serde::Serialize;
 use serde_json::json;
-use solana_client::rpc_request::TokenAccountsFilter;
+use solana_client::{client_error::ClientError, rpc_request::TokenAccountsFilter};
 use solana_pubkey::Pubkey;
+use solana_sdk::slot_history::Slot;
 
 pub type SurfpoolResult<T> = std::result::Result<T, SurfpoolError>;
 
@@ -367,4 +368,18 @@ impl SurfpoolError {
             "sigVerify may not be used with replaceRecentBlockhash",
         ))
     }
+
+    pub fn slot_too_old(slot: Slot) -> Self {
+        Self(Error::invalid_params(format!(
+            "Requested {slot} is before the first local slot, and no remote RPC was provided."
+        )))
+    }
+
+    pub fn get_block(e: ClientError, block: Slot) -> Self {
+        let mut error = Error::internal_error();
+        error.data = Some(json!(format!(
+            "Failed to get block {block} from remote: {e}"
+        )));
+        Self(error)
+    }
 }

crates/core/src/rpc/full.rs

@@ -720,7 +720,7 @@ pub trait Full {
     /// {
     ///   "jsonrpc": "2.0",
     ///   "id": 1,
-    ///   "result": 1620000000
+    ///   "result": 1752080472
     /// }
     /// ```
     ///
@@ -1737,24 +1737,44 @@ impl Full for SurfpoolFullRpc {
         &self,
         meta: Self::Metadata,
         slot: Slot,
-        _config: Option<RpcEncodingConfigWrapper<RpcBlockConfig>>,
+        config: Option<RpcEncodingConfigWrapper<RpcBlockConfig>>,
     ) -> BoxFuture<Result<Option<UiConfirmedBlock>>> {
-        let svm_locker = match meta.get_svm_locker() {
-            Ok(locker) => locker,
+        let config = config.map(|c| c.convert_to_current()).unwrap_or_default();
+
+        let SurfnetRpcContext {
+            svm_locker,
+            remote_ctx,
+        } = match meta.get_rpc_context(config.commitment) {
+            Ok(res) => res,
             Err(e) => return e.into(),
         };
 
         Box::pin(async move {
-            Ok(svm_locker.with_svm_reader(|svm_reader| svm_reader.get_block_at_slot(slot)))
+            let remote_client = remote_ctx.as_ref().map(|(client, _)| client.clone());
+            let result = svm_locker.get_block(&remote_client, &slot, &config).await;
+            Ok(result?.inner)
         })
     }
 
     fn get_block_time(
         &self,
-        _meta: Self::Metadata,
-        _slot: Slot,
+        meta: Self::Metadata,
+        slot: Slot,
     ) -> BoxFuture<Result<Option<UnixTimestamp>>> {
-        Box::pin(async { Ok(None) })
+        let svm_locker = match meta.get_svm_locker() {
+            Ok(locker) => locker,
+            Err(e) => return e.into(),
+        };
+
+        Box::pin(async move {
+            let block_time = svm_locker.with_svm_reader(|svm_reader| {
+                svm_reader
+                    .blocks
+                    .get(&slot)
+                    .map(|block| (block.block_time / 1000) as UnixTimestamp)
+            });
+            Ok(block_time)
+        })
     }
 
     fn get_blocks(
@@ -1771,7 +1791,10 @@ impl Full for SurfpoolFullRpc {
         };
 
         let config = config.unwrap_or_default();
-        let commitment = config.commitment.unwrap_or_default();
+        // get blocks should default to processed rather than finalized to default to the most recent
+        let commitment = config.commitment.unwrap_or(CommitmentConfig {
+            commitment: CommitmentLevel::Processed,
+        });
 
         const MAX_SLOT_RANGE: u64 = 500_000;
         if let Some(end) = end_slot {
@@ -2936,7 +2959,7 @@ mod tests {
         assert_eq!(res, None);
     }
 
-    #[tokio::test]
+    #[tokio::test(flavor = "multi_thread")]
     async fn test_get_block_time() {
         let setup = TestSetup::new(SurfpoolFullRpc);
         let res = setup
@@ -3656,7 +3679,6 @@ mod tests {
 
         {
             let mut svm_writer = setup.context.svm_locker.0.write().await;
-
             for slot in 100..=110 {
                 svm_writer.blocks.insert(
                     slot,
@@ -3670,7 +3692,6 @@ mod tests {
                     },
                 );
             }
-
             svm_writer.latest_epoch_info.absolute_slot = 110;
         }
 
@@ -3682,7 +3703,7 @@ mod tests {
                 100,
                 Some(RpcBlocksConfigWrapper::EndSlotOnly(Some(105))),
                 Some(RpcContextConfig {
-                    commitment: None,
+                    commitment: Some(CommitmentConfig::finalized()),
                     min_context_slot: Some(105),
                 }),
             )

crates/core/src/surfnet/locker.rs

@@ -15,7 +15,7 @@ use solana_account_decoder::{
 use solana_address_lookup_table_interface::state::AddressLookupTable;
 use solana_client::{
     rpc_config::{
-        RpcAccountInfoConfig, RpcLargestAccountsConfig, RpcLargestAccountsFilter,
+        RpcAccountInfoConfig, RpcBlockConfig, RpcLargestAccountsConfig, RpcLargestAccountsFilter,
         RpcSignaturesForAddressConfig,
     },
     rpc_filter::RpcFilterType,
@@ -44,7 +44,8 @@ use solana_signature::Signature;
 use solana_transaction_error::TransactionError;
 use solana_transaction_status::{
     EncodedConfirmedTransactionWithStatusMeta,
-    TransactionConfirmationStatus as SolanaTransactionConfirmationStatus, UiTransactionEncoding,
+    TransactionConfirmationStatus as SolanaTransactionConfirmationStatus, UiConfirmedBlock,
+    UiTransactionEncoding,
 };
 use spl_token::state::Mint;
 use spl_token_2022::extension::StateWithExtensions;
@@ -1752,6 +1753,47 @@ impl SurfnetSvmLocker {
 }
 
 impl SurfnetSvmLocker {
+    pub fn get_first_local_slot(&self) -> Option<Slot> {
+        self.with_svm_reader(|svm_reader| svm_reader.blocks.keys().min().copied())
+    }
+
+    pub async fn get_block(
+        &self,
+        remote_ctx: &Option<SurfnetRemoteClient>,
+        slot: &Slot,
+        config: &RpcBlockConfig,
+    ) -> SurfpoolContextualizedResult<Option<UiConfirmedBlock>> {
+        let first_local_slot = self.get_first_local_slot();
+
+        let result = if first_local_slot.is_some() && first_local_slot.unwrap() > *slot {
+            match remote_ctx {
+                Some(remote_client) => Some(remote_client.get_block(slot, *config).await?),
+                None => return Err(SurfpoolError::slot_too_old(*slot)),
+            }
+        } else {
+            self.get_block_local(slot, config).inner
+        };
+
+        Ok(SvmAccessContext {
+            slot: *slot,
+            latest_epoch_info: self.get_epoch_info(),
+            latest_blockhash: self
+                .get_latest_blockhash(&CommitmentConfig::processed())
+                .unwrap_or_default(),
+            inner: result,
+        })
+    }
+
+    pub fn get_block_local(
+        &self,
+        slot: &Slot,
+        config: &RpcBlockConfig,
+    ) -> SvmAccessContext<Option<UiConfirmedBlock>> {
+        self.with_contextualized_svm_reader(|svm_reader| {
+            svm_reader.get_block_at_slot(*slot, config)
+        })
+    }
+
     pub fn get_genesis_hash_local(&self) -> SvmAccessContext<Hash> {
         self.with_contextualized_svm_reader(|svm_reader| svm_reader.genesis_config.hash())
     }
@@ -1786,6 +1828,12 @@ impl SurfnetSvmLocker {
         self.with_svm_reader(|svm_reader| svm_reader.get_latest_absolute_slot())
     }
 
+    /// Retrieves the latest blockhash for the given commitment config from the underlying SVM.
+    pub fn get_latest_blockhash(&self, config: &CommitmentConfig) -> Option<Hash> {
+        let slot = self.get_slot_for_commitment(config);
+        self.with_svm_reader(|svm_reader| svm_reader.blockhash_for_slot(slot))
+    }
+
     pub fn get_slot_for_commitment(&self, commitment: &CommitmentConfig) -> Slot {
         self.with_svm_reader(|svm_reader| {
             let slot = svm_reader.get_latest_absolute_slot();

crates/core/src/surfnet/remote.rs

@@ -6,7 +6,7 @@ use solana_client::{
     nonblocking::rpc_client::RpcClient,
     rpc_client::GetConfirmedSignaturesForAddress2Config,
     rpc_config::{
-        RpcAccountInfoConfig, RpcLargestAccountsConfig, RpcProgramAccountsConfig,
+        RpcAccountInfoConfig, RpcBlockConfig, RpcLargestAccountsConfig, RpcProgramAccountsConfig,
         RpcSignaturesForAddressConfig, RpcTokenAccountsFilter,
     },
     rpc_filter::RpcFilterType,
@@ -16,13 +16,14 @@ use solana_client::{
         RpcTokenAccountBalance,
     },
 };
+use solana_clock::Slot;
 use solana_commitment_config::CommitmentConfig;
 use solana_epoch_info::EpochInfo;
 use solana_hash::Hash;
 use solana_pubkey::Pubkey;
 use solana_sdk::bpf_loader_upgradeable::get_program_data_address;
 use solana_signature::Signature;
-use solana_transaction_status::UiTransactionEncoding;
+use solana_transaction_status::{UiConfirmedBlock, UiTransactionEncoding};
 
 use super::GetTransactionResult;
 use crate::{
@@ -304,6 +305,17 @@ impl SurfnetRemoteClient {
             .await
             .map_err(SurfpoolError::get_signatures_for_address)
     }
+
+    pub async fn get_block(
+        &self,
+        slot: &Slot,
+        config: RpcBlockConfig,
+    ) -> SurfpoolResult<UiConfirmedBlock> {
+        self.client
+            .get_block_with_config(*slot, config)
+            .await
+            .map_err(|e| SurfpoolError::get_block(e, *slot))
+    }
 }
 
 /// Handles remote RPC calls, returning a `RemoteRpcResult` indicating whether the method was supported.