[Feature] RPC blocks support positive sequence

chain/api/src/chain.rs

@@ -34,9 +34,15 @@ pub trait ChainReader {
     fn get_header(&self, hash: HashValue) -> Result<Option<BlockHeader>>;
     fn get_header_by_number(&self, number: BlockNumber) -> Result<Option<BlockHeader>>;
     fn get_block_by_number(&self, number: BlockNumber) -> Result<Option<Block>>;
-    /// Get latest `count` blocks before `number`. if `number` is absent, use head block number.
+    /// if  `reverse` is true , get latest `count` blocks before `number`. if `number` is absent, use head block number.
+    /// if  `reverse` is false , get `count` blocks after `number` . if `number` is absent, use head block number.
     /// the block of `number` is inclusive.
-    fn get_blocks_by_number(&self, number: Option<BlockNumber>, count: u64) -> Result<Vec<Block>>;
+    fn get_blocks_by_number(
+        &self,
+        number: Option<BlockNumber>,
+        reverse: bool,
+        count: u64,
+    ) -> Result<Vec<Block>>;
     fn get_block(&self, hash: HashValue) -> Result<Option<Block>>;
     /// Get block hash by block number, if not exist, return None
     fn get_hash_by_number(&self, number: BlockNumber) -> Result<Option<HashValue>>;

chain/api/src/message.rs

@@ -39,7 +39,7 @@ pub enum ChainRequest {
     GetEventsByTxnHash {
         txn_hash: HashValue,
     },
-    GetBlocksByNumber(Option<BlockNumber>, u64),
+    GetBlocksByNumber(Option<BlockNumber>, bool, u64),
     MainEvents(Filter),
     GetBlockIds {
         start_number: BlockNumber,

chain/api/src/service.rs

@@ -42,7 +42,12 @@ pub trait ReadableChainService {
     fn main_block_header_by_number(&self, number: BlockNumber) -> Result<Option<BlockHeader>>;
     fn main_block_info_by_number(&self, number: BlockNumber) -> Result<Option<BlockInfo>>;
     fn main_startup_info(&self) -> StartupInfo;
-    fn main_blocks_by_number(&self, number: Option<BlockNumber>, count: u64) -> Result<Vec<Block>>;
+    fn main_blocks_by_number(
+        &self,
+        number: Option<BlockNumber>,
+        reverse: bool,
+        count: u64,
+    ) -> Result<Vec<Block>>;
     fn get_main_events(&self, filter: Filter) -> Result<Vec<ContractEventInfo>>;
     fn get_block_ids(
         &self,
@@ -104,6 +109,7 @@ pub trait ChainAsyncService:
     async fn main_blocks_by_number(
         &self,
         number: Option<BlockNumber>,
+        reverse: bool,
         count: u64,
     ) -> Result<Vec<Block>>;
     async fn main_block_header_by_number(&self, number: BlockNumber)
@@ -307,10 +313,11 @@ where
     async fn main_blocks_by_number(
         &self,
         number: Option<BlockNumber>,
+        reverse: bool,
         count: u64,
     ) -> Result<Vec<Block>> {
         if let ChainResponse::BlockVec(blocks) = self
-            .send(ChainRequest::GetBlocksByNumber(number, count))
+            .send(ChainRequest::GetBlocksByNumber(number, reverse, count))
             .await??
         {
             Ok(blocks)

chain/service/src/chain_service.rs

@@ -147,8 +147,8 @@ impl ServiceHandler<Self, ChainRequest> for ChainReaderService {
             ChainRequest::GetTransactionInfo(hash) => Ok(ChainResponse::TransactionInfo(
                 self.inner.get_transaction_info(hash)?,
             )),
-            ChainRequest::GetBlocksByNumber(number, count) => Ok(ChainResponse::BlockVec(
-                self.inner.main_blocks_by_number(number, count)?,
+            ChainRequest::GetBlocksByNumber(number, reverse, count) => Ok(ChainResponse::BlockVec(
+                self.inner.main_blocks_by_number(number, reverse, count)?,
             )),
             ChainRequest::GetBlockTransactionInfos(block_id) => Ok(
                 ChainResponse::TransactionInfos(self.inner.get_block_txn_infos(block_id)?),
@@ -366,8 +366,13 @@ impl ReadableChainService for ChainReaderServiceInner {
     fn main_startup_info(&self) -> StartupInfo {
         self.startup_info.clone()
     }
-    fn main_blocks_by_number(&self, number: Option<BlockNumber>, count: u64) -> Result<Vec<Block>> {
-        self.main.get_blocks_by_number(number, count)
+    fn main_blocks_by_number(
+        &self,
+        number: Option<BlockNumber>,
+        reverse: bool,
+        count: u64,
+    ) -> Result<Vec<Block>> {
+        self.main.get_blocks_by_number(number, reverse, count)
     }
 
     fn get_main_events(&self, filter: Filter) -> Result<Vec<ContractEventInfo>> {

chain/src/chain.rs

@@ -561,17 +561,30 @@ impl ChainReader for BlockChain {
             })
     }
 
-    fn get_blocks_by_number(&self, number: Option<BlockNumber>, count: u64) -> Result<Vec<Block>> {
+    fn get_blocks_by_number(
+        &self,
+        number: Option<BlockNumber>,
+        reverse: bool,
+        count: u64,
+    ) -> Result<Vec<Block>> {
         let end_num = match number {
             None => self.current_header().number(),
             Some(number) => number,
         };
 
         let num_leaves = self.block_accumulator.num_leaves();
-        if end_num > num_leaves {
+
+        if end_num > num_leaves.saturating_sub(1) {
             bail!("Can not find block by number {}", end_num);
-        }
-        let ids = self.get_block_ids(end_num, true, count)?;
+        };
+
+        let len = if !reverse && (end_num.saturating_add(count) > num_leaves.saturating_sub(1)) {
+            num_leaves.saturating_sub(end_num)
+        } else {
+            count
+        };
+
+        let ids = self.get_block_ids(end_num, reverse, len)?;
         let block_opts = self.storage.get_blocks(ids)?;
         let mut blocks = vec![];
         for (idx, block) in block_opts.into_iter().enumerate() {

chain/tests/test_block_chain.rs

@@ -464,25 +464,53 @@ fn test_get_blocks_by_number() -> Result<()> {
     let mut mock_chain = MockChain::new(ChainNetwork::new_test()).unwrap();
     let blocks = mock_chain
         .head()
-        .get_blocks_by_number(None, u64::max_value())?;
+        .get_blocks_by_number(None, true, u64::max_value())?;
     assert_eq!(blocks.len(), 1, "at least genesis block should contains.");
     let times = 10;
     mock_chain.produce_and_apply_times(times).unwrap();
 
     let blocks = mock_chain
         .head()
-        .get_blocks_by_number(None, u64::max_value())?;
+        .get_blocks_by_number(None, true, u64::max_value())?;
     assert_eq!(blocks.len(), 11);
 
     let number = blocks.len() as u64;
-    let number = number.saturating_add(1);
+    let result =
+        mock_chain
+            .head()
+            .get_blocks_by_number(Some(blocks.len() as u64), true, u64::max_value());
+    assert!(
+        result.is_err(),
+        "result cannot find block by number {}",
+        number
+    );
+
+    let number = blocks.len() as u64;
+    let number = number.saturating_add(2);
     let result = mock_chain
         .head()
-        .get_blocks_by_number(Some(blocks.len() as u64 + 1), u64::max_value());
+        .get_blocks_by_number(Some(number), true, u64::max_value());
     assert!(
         result.is_err(),
         "result cannot find block by number {}",
         number
     );
+
+    let blocks = mock_chain.head().get_blocks_by_number(Some(9), true, 3)?;
+    assert_eq!(blocks.len(), 3);
+
+    let blocks = mock_chain
+        .head()
+        .get_blocks_by_number(Some(0), false, u64::max_value())?;
+    assert_eq!(blocks.len(), 11);
+
+    let blocks = mock_chain
+        .head()
+        .get_blocks_by_number(Some(9), false, u64::max_value())?;
+    assert_eq!(blocks.len(), 2);
+
+    let blocks = mock_chain.head().get_blocks_by_number(Some(6), false, 3)?;
+    assert_eq!(blocks.len(), 3);
+
     Ok(())
 }

cmd/starcoin/src/chain/list_block_cmd.rs

@@ -6,6 +6,7 @@ use crate::StarcoinOpt;
 use anyhow::Result;
 use clap::Parser;
 use scmd::{CommandAction, ExecContext};
+use starcoin_rpc_api::chain::GetBlocksOption;
 use starcoin_rpc_api::types::BlockHeaderView;
 use starcoin_types::block::BlockNumber;
 
@@ -17,6 +18,8 @@ pub struct ListBlockOpt {
     number: Option<BlockNumber>,
     #[clap(name = "count", long, short = 'c', default_value = "10")]
     count: u64,
+    #[clap(name = "reverse", long, short = 'r', default_value = "true")]
+    reverse: bool,
 }
 
 pub struct ListBlockCommand;
@@ -33,7 +36,13 @@ impl CommandAction for ListBlockCommand {
     ) -> Result<Self::ReturnItem> {
         let client = ctx.state().client();
         let opt = ctx.opt();
-        let blocks = client.chain_get_blocks_by_number(opt.number, opt.count)?;
+        let blocks = client.chain_get_blocks_by_number(
+            opt.number,
+            opt.count,
+            Some(GetBlocksOption {
+                reverse: opt.reverse,
+            }),
+        )?;
         let block_view = blocks.into_iter().map(|block| block.header).collect();
         Ok(block_view)
     }

config/src/lib.rs

@@ -562,6 +562,6 @@ pub fn check_open_fds_limit(max_files: u64) -> Result<(), ConfigError> {
 }
 
 #[cfg(not(unix))]
-pub fn check_open_fds_limit(max_files: u64) -> Result<(), ConfigError> {
+pub fn check_open_fds_limit(_max_files: u64) -> Result<(), ConfigError> {
     Ok(())
 }

rpc/api/generated_rpc_schema/chain.json

@@ -1366,6 +1366,23 @@
             "format": "uint64",
             "minimum": 0.0
           }
+        },
+        {
+          "name": "option",
+          "schema": {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "title": "Nullable_GetBlocksOption",
+            "type": [
+              "object",
+              "null"
+            ],
+            "properties": {
+              "reverse": {
+                "default": true,
+                "type": "boolean"
+              }
+            }
+          }
         }
       ],
       "result": {

rpc/api/src/chain/mod.rs

@@ -45,6 +45,7 @@ pub trait ChainApi {
         &self,
         number: Option<BlockNumber>,
         count: u64,
+        option: Option<GetBlocksOption>,
     ) -> FutureResult<Vec<BlockView>>;
     #[rpc(name = "chain.get_block_info_by_number")]
     fn get_block_info_by_number(&self, number: BlockNumber) -> FutureResult<Option<BlockInfoView>>;
@@ -138,6 +139,16 @@ pub struct GetBlockOption {
     pub raw: bool,
 }
 
+#[derive(Copy, Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub struct GetBlocksOption {
+    #[serde(default = "defautl_true")]
+    pub reverse: bool,
+}
+
+fn defautl_true() -> bool {
+    true
+}
+
 #[derive(Copy, Clone, Default, Serialize, Deserialize, JsonSchema)]
 pub struct GetEventOption {
     #[serde(default)]

rpc/client/src/lib.rs

@@ -21,7 +21,9 @@ use starcoin_abi_types::{FunctionABI, ModuleABI, StructInstantiation};
 use starcoin_account_api::AccountInfo;
 use starcoin_crypto::HashValue;
 use starcoin_logger::{prelude::*, LogPattern};
-use starcoin_rpc_api::chain::{GetBlockOption, GetEventOption, GetTransactionOption};
+use starcoin_rpc_api::chain::{
+    GetBlockOption, GetBlocksOption, GetEventOption, GetTransactionOption,
+};
 use starcoin_rpc_api::node::NodeInfo;
 use starcoin_rpc_api::service::RpcAsyncService;
 use starcoin_rpc_api::state::{
@@ -753,9 +755,14 @@ impl RpcClient {
         &self,
         number: Option<BlockNumber>,
         count: u64,
+        option: Option<GetBlocksOption>,
     ) -> anyhow::Result<Vec<BlockView>> {
-        self.call_rpc_blocking(|inner| inner.chain_client.get_blocks_by_number(number, count))
-            .map_err(map_err)
+        self.call_rpc_blocking(|inner| {
+            inner
+                .chain_client
+                .get_blocks_by_number(number, count, option)
+        })
+        .map_err(map_err)
     }
 
     pub fn chain_get_transaction(

rpc/server/src/module/chain_rpc.rs

@@ -9,7 +9,9 @@ use starcoin_config::NodeConfig;
 use starcoin_crypto::HashValue;
 use starcoin_logger::prelude::*;
 use starcoin_resource_viewer::MoveValueAnnotator;
-use starcoin_rpc_api::chain::{ChainApi, GetBlockOption, GetEventOption, GetTransactionOption};
+use starcoin_rpc_api::chain::{
+    ChainApi, GetBlockOption, GetBlocksOption, GetEventOption, GetTransactionOption,
+};
 use starcoin_rpc_api::types::pubsub::EventFilter;
 use starcoin_rpc_api::types::{
     BlockHeaderView, BlockInfoView, BlockTransactionsView, BlockView, ChainId, ChainInfoView,
@@ -141,6 +143,7 @@ where
         &self,
         number: Option<BlockNumber>,
         count: u64,
+        option: Option<GetBlocksOption>,
     ) -> FutureResult<Vec<BlockView>> {
         let service = self.service.clone();
         let config = self.config.clone();
@@ -153,8 +156,9 @@ where
             let max_return_num = count
                 .min(end_block_number + 1)
                 .min(config.rpc.block_query_max_range());
+            let reverse = !option.unwrap_or_default().reverse;
             let block = service
-                .main_blocks_by_number(number, max_return_num)
+                .main_blocks_by_number(number, reverse, max_return_num)
                 .await?;
 
             block

scripts/nextest.sh

@@ -14,7 +14,7 @@ ulimit -a
 
 # install cargo-nextest
 echo "Setup cargo-nextest."
-cargo nextest -V >/dev/null 2>&1 || cargo install cargo-nextest
+cargo nextest -V >/dev/null 2>&1 || cargo install cargo-nextest --locked
 
 # following options are tuned for current self hosted CI machine
 # --test-threads 12, proper test concurrency level, balance failure rate and test speed

testsuite/tests/steps/sync.rs

@@ -22,7 +22,7 @@ pub fn steps() -> Steps<MyWorld> {
             let local_client = world.rpc_client2.as_ref().take().unwrap();
             let status = client.clone().node_status();
             assert!(status.is_ok());
-            let list_block = client.chain_get_blocks_by_number(None, 1).unwrap();
+            let list_block = client.chain_get_blocks_by_number(None, true, 1).unwrap();
             let max_num = list_block[0].header.number.0;
             let local_max_block = local_client
                 .chain_get_block_by_number(max_num, None)

vm/starcoin-transactional-test-harness/src/fork_chain.rs

@@ -11,8 +11,8 @@ use starcoin_abi_decoder::decode_txn_payload;
 use starcoin_accumulator::{node::AccumulatorStoreType, Accumulator, MerkleAccumulator};
 use starcoin_config::{BuiltinNetworkID, ChainNetworkID};
 use starcoin_crypto::HashValue;
-use starcoin_rpc_api::chain::ChainApiClient;
 use starcoin_rpc_api::chain::{ChainApi, GetBlockOption};
+use starcoin_rpc_api::chain::{ChainApiClient, GetBlocksOption};
 use starcoin_rpc_api::types::{
     BlockInfoView, BlockTransactionsView, BlockView, ChainId, ChainInfoView,
     SignedUserTransactionView, TransactionInfoView, TransactionView,
@@ -299,6 +299,7 @@ impl ChainApi for MockChainApi {
         &self,
         _number: Option<BlockNumber>,
         _count: u64,
+        _option: Option<GetBlocksOption>,
     ) -> FutureResult<Vec<BlockView>> {
         let fut = async move {
             bail!("not implemented.");