[Backport] merge several fixes into 118 for next rc release

chain/src/init_load_unverified.rs

@@ -93,6 +93,15 @@ impl InitLoadUnverified {
             let unverified_hashes: Vec<packed::Byte32> =
                 self.find_unverified_block_hashes(check_unverified_number);
 
+            if check_unverified_number > tip_number && unverified_hashes.is_empty() {
+                info!(
+                    "no unverified blocks found after tip, current tip: {}-{}",
+                    tip_number,
+                    self.shared.snapshot().tip_hash()
+                );
+                return;
+            }
+
             for unverified_hash in unverified_hashes {
                 f(&unverified_hash);
             }

deny.toml

@@ -70,6 +70,10 @@ feature-depth = 1
 # A list of advisory IDs to ignore. Note that ignored advisories will still
 # output a note when they are encountered.
 ignore = [
+# https://rustsec.org/advisories/RUSTSEC-2024-0363
+# https://github.com/launchbadge/sqlx/issues/3440
+# The queries for the rich indexer receive input parameters via RPC, and the data size is far less than 4GB, so this issue can be temporarily ignored while waiting for sqlx to be fixed.
+  "RUSTSEC-2024-0363",
 # https://rustsec.org/advisories/RUSTSEC-2022-0090
 # It was sometimes possible for SQLite versions >= 1.0.12, < 3.39.2 to allow an array-bounds overflow when large string were input into SQLite's `printf` function.
   "RUSTSEC-2022-0090",

rpc/README.md

@@ -109,6 +109,7 @@ The crate `ckb-rpc`'s minimum supported rustc version is 1.71.1.
         * [Method `remove_transaction`](#pool-remove_transaction)
         * [Method `tx_pool_info`](#pool-tx_pool_info)
         * [Method `clear_tx_pool`](#pool-clear_tx_pool)
+        * [Method `clear_tx_verify_queue`](#pool-clear_tx_verify_queue)
         * [Method `get_raw_tx_pool`](#pool-get_raw_tx_pool)
         * [Method `get_pool_tx_detail_info`](#pool-get_pool_tx_detail_info)
         * [Method `tx_pool_ready`](#pool-tx_pool_ready)
@@ -4748,6 +4749,37 @@ Response
 }
 ```
 
+<a id="pool-clear_tx_verify_queue"></a>
+#### Method `clear_tx_verify_queue`
+* `clear_tx_verify_queue()`
+
+* result: `null`
+
+Removes all transactions from the verification queue.
+
+###### Examples
+
+Request
+
+```json
+{
+  "id": 42,
+  "jsonrpc": "2.0",
+  "method": "clear_tx_verify_queue",
+  "params": []
+}
+```
+
+Response
+
+```json
+{
+  "id": 42,
+  "jsonrpc": "2.0",
+  "result": null
+}
+```
+
 <a id="pool-get_raw_tx_pool"></a>
 #### Method `get_raw_tx_pool`
 * `get_raw_tx_pool(verbose)`

rpc/src/module/pool.rs

@@ -322,6 +322,33 @@ pub trait PoolRpc {
     #[rpc(name = "clear_tx_pool")]
     fn clear_tx_pool(&self) -> Result<()>;
 
+    /// Removes all transactions from the verification queue.
+    ///
+    /// ## Examples
+    ///
+    /// Request
+    ///
+    /// ```json
+    /// {
+    ///   "id": 42,
+    ///   "jsonrpc": "2.0",
+    ///   "method": "clear_tx_verify_queue",
+    ///   "params": []
+    /// }
+    /// ```
+    ///
+    /// Response
+    ///
+    /// ```json
+    /// {
+    ///   "id": 42,
+    ///   "jsonrpc": "2.0",
+    ///   "result": null
+    /// }
+    /// ```
+    #[rpc(name = "clear_tx_verify_queue")]
+    fn clear_tx_verify_queue(&self) -> Result<()>;
+
     /// Returns all transaction ids in tx pool as a json array of string transaction ids.
     /// ## Params
     ///
@@ -662,6 +689,15 @@ impl PoolRpc for PoolRpcImpl {
         Ok(())
     }
 
+    fn clear_tx_verify_queue(&self) -> Result<()> {
+        let tx_pool = self.shared.tx_pool_controller();
+        tx_pool
+            .clear_verify_queue()
+            .map_err(|err| RPCError::custom(RPCError::Invalid, err.to_string()))?;
+
+        Ok(())
+    }
+
     fn get_raw_tx_pool(&self, verbose: Option<bool>) -> Result<RawTxPool> {
         let tx_pool = self.shared.tx_pool_controller();
 

sync/src/synchronizer/mod.rs

@@ -680,6 +680,11 @@ impl Synchronizer {
             return;
         }
 
+        if ckb_stop_handler::has_received_stop_signal() {
+            info!("received stop signal, stop find_blocks_to_fetch");
+            return;
+        }
+
         let unverified_tip = self.shared.active_chain().unverified_tip_number();
 
         let disconnect_list = {

test/src/node.rs

@@ -361,7 +361,7 @@ impl Node {
         let timestamp = block.timestamp();
         let uncle = block
             .as_advanced_builder()
-            .timestamp((timestamp + 1).pack())
+            .timestamp((timestamp - 1).pack())
             .build();
         (block, uncle)
     }
@@ -701,6 +701,7 @@ impl Node {
             }
         };
 
+        self.wait_find_unverified_blocks_finished();
         self.wait_tx_pool_ready();
 
         self.set_process_guard(ProcessGuard {

test/src/specs/sync/sync_churn.rs

@@ -60,6 +60,11 @@ impl Spec for SyncChurn {
                 if too_many_blocks || restart_stopped_rx.try_recv().is_ok() {
                     break;
                 }
+                info!(
+                    "mining_node {}, tip: {}",
+                    mining_node.node_id(),
+                    mining_node.get_tip_block_number()
+                );
                 waiting_for_sync(&mining_nodes);
             }
         });

test/src/specs/tx_pool/send_large_cycles_tx.rs

@@ -100,6 +100,7 @@ impl Spec for SendLargeCyclesTxToRelay {
         let node0 = &nodes[0];
         let node1 = &nodes[1];
 
+        node0.mine_until_out_bootstrap_period();
         node1.mine_until_out_bootstrap_period();
         node0.connect(node1);
         info!("Generate large cycles tx");

tx-pool/src/process.rs

@@ -448,7 +448,7 @@ impl TxPoolService {
                     self.process_orphan_tx(&tx).await;
                 }
                 Err(reject) => {
-                    debug!(
+                    info!(
                         "after_process {} {} remote reject: {} ",
                         tx_hash, peer, reject
                     );
@@ -686,6 +686,10 @@ impl TxPoolService {
 
         if let Some(declared) = declared_cycles {
             if declared != verified.cycles {
+                info!(
+                    "process_tx declared cycles not match verified cycles, declared: {:?} verified: {:?}, tx: {:?}",
+                    declared, verified.cycles, tx
+                );
                 return Some((
                     Err(Reject::DeclaredWrongCycles(declared, verified.cycles)),
                     snapshot,

tx-pool/src/service.rs

@@ -110,6 +110,7 @@ pub(crate) enum Message {
     GetTransactionWithStatus(Request<Byte32, GetTransactionWithStatusResult>),
     NewUncle(Notify<UncleBlockView>),
     ClearPool(Request<Arc<Snapshot>, ()>),
+    ClearVerifyQueue(Request<(), ()>),
     GetAllEntryInfo(Request<(), TxPoolEntryInfo>),
     GetAllIds(Request<(), TxPoolIds>),
     SavePool(Request<(), ()>),
@@ -322,6 +323,11 @@ impl TxPoolController {
         send_message!(self, ClearPool, new_snapshot)
     }
 
+    /// Clears the tx-verify-queue.
+    pub fn clear_verify_queue(&self) -> Result<(), AnyError> {
+        send_message!(self, ClearVerifyQueue, ())
+    }
+
     /// TODO(doc): @zhangsoledad
     pub fn get_all_entry_info(&self) -> Result<TxPoolEntryInfo, AnyError> {
         send_message!(self, GetAllEntryInfo, ())
@@ -914,6 +920,12 @@ async fn process(mut service: TxPoolService, message: Message) {
                 error!("Responder sending clear_pool failed {:?}", e)
             };
         }
+        Message::ClearVerifyQueue(Request { responder, .. }) => {
+            service.verify_queue.write().await.clear();
+            if let Err(e) = responder.send(()) {
+                error!("Responder sending clear_verify_queue failed {:?}", e)
+            };
+        }
         Message::GetPoolTxDetails(Request {
             responder,
             arguments: tx_hash,

tx-pool/src/verify_mgr.rs

@@ -76,6 +76,10 @@ impl Worker {
 
     async fn process_inner(&mut self) {
         loop {
+            if self.exit_signal.is_cancelled() {
+                info!("Verify worker::process_inner exit_signal is cancelled");
+                return;
+            }
             if self.status != ChunkCommand::Resume {
                 return;
             }
@@ -170,7 +174,6 @@ impl VerifyMgr {
     }
 
     fn send_child_command(&self, command: ChunkCommand) {
-        //info!("[verify-test] verify-mgr send child command: {:?}", command);
         for w in &self.workers {
             if let Err(err) = w.0.send(command.clone()) {
                 info!("send worker command failed, error: {}", err);