Abort blocks by ID

crates/starknet-devnet-core/src/blocks/mod.rs

@@ -79,7 +79,7 @@ impl StarknetBlocks {
         self.last_block_hash = Some(hash);
     }
 
-    fn get_by_num(&self, num: &BlockNumber) -> Option<&StarknetBlock> {
+    pub(crate) fn get_by_num(&self, num: &BlockNumber) -> Option<&StarknetBlock> {
         let block_hash = self.num_to_hash.get(num)?;
         let block = self.hash_to_block.get(block_hash)?;
 

crates/starknet-devnet-core/src/starknet/mod.rs

@@ -933,6 +933,9 @@ impl Starknet {
     pub fn get_block(&self, block_id: &BlockId) -> DevnetResult<&StarknetBlock> {
         self.blocks.get_by_block_id(block_id).ok_or(Error::NoBlock)
     }
+    pub fn get_block_by_number(&self, block_number: BlockNumber) -> DevnetResult<&StarknetBlock> {
+        self.blocks.get_by_num(&block_number).ok_or(Error::NoBlock)
+    }
 
     pub fn get_block_with_transactions(&self, block_id: &BlockId) -> DevnetResult<BlockResult> {
         let block = self.get_block(block_id)?;

crates/starknet-devnet-server/src/api/http/endpoints/blocks.rs

@@ -37,8 +37,24 @@ pub(crate) async fn abort_blocks_impl(
     data: AbortingBlocks,
 ) -> HttpApiResult<AbortedBlocks> {
     let mut starknet = api.starknet.write().await;
+
+    let starting_block_hash = match data.starting_block_hash {
+        Some(block_hash) => block_hash,
+        None => match data.starting_block_number {
+            Some(block_number) => starknet
+                .get_block_by_number(block_number)
+                .map_err(|err| HttpApiError::BlockAbortError { msg: (err.to_string()) })?
+                .block_hash(),
+            None => {
+                return Err(HttpApiError::BlockAbortError {
+                    msg: "Either starting_block_number or starting_block_hash must be provided"
+                        .to_string(),
+                });
+            }
+        },
+    };
     let aborted = starknet
-        .abort_blocks(data.starting_block_hash)
+        .abort_blocks(starting_block_hash)
         .map_err(|err| HttpApiError::BlockAbortError { msg: (err.to_string()) })?;
 
     Ok(AbortedBlocks { aborted })

crates/starknet-devnet-server/src/api/http/models.rs

@@ -7,6 +7,7 @@ use starknet_types::rpc::eth_address::EthAddressWrapper;
 use starknet_types::rpc::messaging::{MessageToL1, MessageToL2};
 use starknet_types::rpc::transaction_receipt::FeeUnit;
 use starknet_types::serde_helpers::dec_string::deserialize_biguint;
+use starknet_types::starknet_api::block::BlockNumber;
 
 use crate::api::http::error::HttpApiError;
 
@@ -51,7 +52,8 @@ pub struct CreatedBlock {
 #[serde(deny_unknown_fields)]
 #[cfg_attr(test, derive(Debug))]
 pub struct AbortingBlocks {
-    pub(crate) starting_block_hash: BlockHash,
+    pub(crate) starting_block_number: Option<BlockNumber>,
+    pub(crate) starting_block_hash: Option<BlockHash>,
 }
 
 #[derive(Serialize)]

crates/starknet-devnet/tests/test_abort_blocks.rs

@@ -5,6 +5,7 @@ mod abort_blocks_tests {
     use server::api::json_rpc::error::ApiError;
     use starknet_rs_core::types::FieldElement;
     use starknet_types::rpc::transaction_receipt::FeeUnit;
+    use starknet_types::starknet_api::block::BlockNumber;
 
     use crate::common::background_devnet::BackgroundDevnet;
     use crate::common::utils::{assert_tx_reverted, to_hex_felt};
@@ -32,6 +33,26 @@ mod abort_blocks_tests {
             .collect()
     }
 
+    async fn abort_blocks_by_number(
+        devnet: &BackgroundDevnet,
+        starting_block_number: &BlockNumber,
+    ) -> Vec<FieldElement> {
+        let mut aborted_blocks = devnet
+            .send_custom_rpc(
+                "devnet_abortBlocks",
+                json!({ "starting_block_number": starting_block_number }),
+            )
+            .await
+            .unwrap();
+
+        let aborted_blocks = aborted_blocks["aborted"].take().as_array().unwrap().clone();
+
+        aborted_blocks
+            .into_iter()
+            .map(|block_hash| serde_json::from_value(block_hash).unwrap())
+            .collect()
+    }
+
     async fn abort_blocks_error(devnet: &BackgroundDevnet, starting_block_hash: &FieldElement) {
         let aborted_blocks_error = devnet
             .send_custom_rpc(
@@ -104,6 +125,37 @@ mod abort_blocks_tests {
         assert_block_rejected(&devnet, &second_block_hash).await;
     }
 
+    #[tokio::test]
+    async fn test_abort_blocks_by_number() {
+        let devnet =
+            BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
+                .await
+                .expect("Could not start Devnet");
+
+        let first_block_hash = devnet.create_block().await.unwrap();
+        let second_block_hash = devnet.create_block().await.unwrap();
+
+        let aborted_blocks = abort_blocks_by_number(&devnet, &BlockNumber(1)).await;
+        assert_eq!(json!(aborted_blocks), json!([second_block_hash, first_block_hash]));
+
+        assert_block_rejected(&devnet, &first_block_hash).await;
+        assert_block_rejected(&devnet, &second_block_hash).await;
+    }
+
+    #[tokio::test]
+    #[should_panic]
+    async fn test_abort_blocks_by_number_out_of_range() {
+        let devnet =
+            BackgroundDevnet::spawn_with_additional_args(&["--state-archive-capacity", "full"])
+                .await
+                .expect("Could not start Devnet");
+
+        devnet.create_block().await.unwrap();
+        devnet.create_block().await.unwrap();
+
+        abort_blocks_by_number(&devnet, &BlockNumber(5)).await;
+    }
+
     #[tokio::test]
     async fn abort_block_with_transaction() {
         let devnet =

website/docs/blocks.md

@@ -114,6 +114,12 @@ POST /abort_blocks
     "starting_block_hash": BLOCK_HASH
 }
 ```
+```
+POST /abort_blocks
+{
+    "starting_block_number": BLOCK_NUMBER
+}
+```
 
 ```
 JSON-RPC
@@ -127,10 +133,24 @@ JSON-RPC
 }
 ```
 
+```
+JSON-RPC
+{
+    "jsonrpc": "2.0",
+    "id": "1",
+    "method": "devnet_abortBlocks",
+    "params": {
+        "starting_block_number": BLOCK_NUMBER
+    }
+}
+```
+
 Response:
 
 ```
 {
     "aborted": [BLOCK_HASH_0, BLOCK_HASH_1, ...]
 }
 ```
+
+If both `starting_block_hash` and `starting_block_number` are passed, `starting_block_hash` is used.