feat(rpc): Add a generate rpc method

zebra-rpc/src/methods/get_block_template_rpcs.rs

@@ -19,7 +19,7 @@ use zebra_chain::{
         Network, NetworkKind, NetworkUpgrade, POW_AVERAGING_WINDOW,
     },
     primitives,
-    serialization::ZcashDeserializeInto,
+    serialization::{ZcashDeserializeInto, ZcashSerialize},
     transparent::{
         self, EXTRA_ZEBRA_COINBASE_DATA, MAX_COINBASE_DATA_LEN, MAX_COINBASE_HEIGHT_DATA_LEN,
     },
@@ -47,7 +47,9 @@ use crate::methods::{
         // TODO: move the types/* modules directly under get_block_template_rpcs,
         //       and combine any modules with the same names.
         types::{
-            get_block_template::GetBlockTemplate,
+            get_block_template::{
+                proposal::TimeSource, proposal_block_from_template, GetBlockTemplate,
+            },
             get_mining_info,
             long_poll::LongPollInput,
             peer_info::PeerInfo,
@@ -283,6 +285,22 @@ pub trait GetBlockTemplateRpc {
         &self,
         address: String,
     ) -> BoxFuture<Result<unified_address::Response>>;
+
+    #[rpc(name = "generate")]
+    /// Mine blocks immediately. Returns the block hashes of the generated blocks.
+    ///
+    /// # Parameters
+    ///
+    /// - `num_blocks`: (numeric, required, example=1) Number of blocks to be generated.
+    ///
+    /// # Notes
+    ///
+    /// Only works if the network of the running zebrad process is `Regtest`.
+    ///
+    /// zcashd reference: [`generate`](https://zcash.github.io/rpc/generate.html)
+    /// method: post
+    /// tags: generating
+    fn generate(&self, num_blocks: u32) -> BoxFuture<Result<Vec<GetBlockHash>>>;
 }
 
 /// RPC method implementations.
@@ -1357,6 +1375,61 @@ where
         }
         .boxed()
     }
+
+    fn generate(&self, num_blocks: u32) -> BoxFuture<Result<Vec<GetBlockHash>>> {
+        let rpc: GetBlockTemplateRpcImpl<
+            Mempool,
+            State,
+            Tip,
+            BlockVerifierRouter,
+            SyncStatus,
+            AddressBook,
+        > = self.clone();
+        let network = self.network.clone();
+
+        async move {
+            if !network.is_regtest() {
+                return Err(Error {
+                    code: ErrorCode::ServerError(0),
+                    message: "generate is only supported on regtest".to_string(),
+                    data: None,
+                });
+            }
+
+            let mut block_hashes = Vec::new();
+            for _ in 0..num_blocks {
+                let block_template = rpc.get_block_template(None).await.map_server_error()?;
+
+                let get_block_template::Response::TemplateMode(block_template) = block_template
+                else {
+                    return Err(Error {
+                        code: ErrorCode::ServerError(0),
+                        message: "error generating block template".to_string(),
+                        data: None,
+                    });
+                };
+
+                let proposal_block = proposal_block_from_template(
+                    &block_template,
+                    TimeSource::CurTime,
+                    NetworkUpgrade::current(&network, Height(block_template.height)),
+                )
+                .map_server_error()?;
+                let hex_proposal_block =
+                    HexData(proposal_block.zcash_serialize_to_vec().map_server_error()?);
+
+                let _submit = rpc
+                    .submit_block(hex_proposal_block, None)
+                    .await
+                    .map_server_error()?;
+
+                block_hashes.push(GetBlockHash(proposal_block.hash()));
+            }
+
+            Ok(block_hashes)
+        }
+        .boxed()
+    }
 }
 
 // Put support functions in a submodule, to keep this file small.