diff --git a/src/ckb/tests/test_utils.rs b/src/ckb/tests/test_utils.rs
index b9fcd7310..f47a8166c 100644
--- a/src/ckb/tests/test_utils.rs
+++ b/src/ckb/tests/test_utils.rs
@@ -472,6 +472,7 @@ impl Actor for MockChainActor {
                 }
             }
             TraceTx(tx, reply_port) => {
+                debug!("Tracing transaction: {:?}", &tx);
                 match state.tx_status.get(&tx.tx_hash).cloned() {
                     Some((tx_view, status)) => {
                         reply_trace_tx(Some(tx_view), status, reply_port);
diff --git a/src/fiber/channel.rs b/src/fiber/channel.rs
index 43e1b75f6..9c09dedac 100644
--- a/src/fiber/channel.rs
+++ b/src/fiber/channel.rs
@@ -1,8 +1,10 @@
 #[cfg(debug_assertions)]
 use crate::fiber::network::DebugEvent;
-use crate::{debug_event, fiber::serde_utils::U64Hex};
+use crate::{
+    debug_event,
+    fiber::{serde_utils::U64Hex, types::BroadcastMessageWithTimestamp},
+};
 use bitflags::bitflags;
-use ckb_jsonrpc_types::BlockNumber;
 use futures::future::OptionFuture;
 use secp256k1::XOnlyPublicKey;
 use tracing::{debug, error, info, trace, warn};
@@ -25,7 +27,7 @@ use crate::{
         },
         serde_utils::{CompactSignatureAsBytes, EntityHex, PubNonceAsBytes},
         types::{
-            AcceptChannel, AddTlc, AnnouncementSignatures, BroadcastMessage, BroadcastMessageQuery,
+            AcceptChannel, AddTlc, AnnouncementSignatures, BroadcastMessageQuery,
             BroadcastMessageQueryFlags, ChannelAnnouncement, ChannelReady, ChannelUpdate,
             ClosingSigned, CommitmentSigned, EcdsaSignature, FiberChannelMessage, FiberMessage,
             Hash256, OpenChannel, PaymentOnionPacket, PeeledPaymentOnionPacket, Privkey, Pubkey,
@@ -47,6 +49,7 @@ use ckb_types::{
     },
     packed::{Bytes, CellInput, CellOutput, OutPoint, Script, Transaction},
     prelude::{AsTransactionBuilder, IntoTransactionView, Pack, Unpack},
+    H256,
 };
 use molecule::prelude::{Builder, Entity};
 use musig2::{
@@ -1709,7 +1712,7 @@ where
         event: ChannelEvent,
     ) -> Result<(), ProcessingChannelError> {
         match event {
-            ChannelEvent::FundingTransactionConfirmed(block_number, tx_index) => {
+            ChannelEvent::FundingTransactionConfirmed(block_hash, tx_index, timestamp) => {
                 debug!("Funding transaction confirmed");
                 let flags = match state.state {
                     ChannelState::AwaitingChannelReady(flags) => flags,
@@ -1723,7 +1726,7 @@ where
                             "Expecting funding transaction confirmed event in state AwaitingChannelReady or after TX_SIGNATURES_SENT, but got state {:?}", &state.state)));
                     }
                 };
-                state.funding_tx_confirmed_at = Some((block_number, tx_index));
+                state.funding_tx_confirmed_at = Some((block_hash, tx_index, timestamp));
                 self.network
                     .send_message(NetworkActorMessage::new_command(
                         NetworkActorCommand::SendFiberMessage(FiberMessageWithPeerId::new(
@@ -1766,7 +1769,7 @@ where
                     self.network
                         .send_message(NetworkActorMessage::new_command(
                             NetworkActorCommand::BroadcastMessages(vec![
-                                BroadcastMessage::ChannelUpdate(update),
+                                BroadcastMessageWithTimestamp::ChannelUpdate(update),
                             ]),
                         ))
                         .expect(ASSUME_NETWORK_ACTOR_ALIVE);
@@ -2766,7 +2769,7 @@ pub struct ChannelActorState {
     #[serde_as(as = "Option<EntityHex>")]
     pub funding_tx: Option<Transaction>,
 
-    pub funding_tx_confirmed_at: Option<(BlockNumber, u32)>,
+    pub funding_tx_confirmed_at: Option<(H256, u32, u64)>,
 
     #[serde_as(as = "Option<EntityHex>")]
     pub funding_udt_type_script: Option<Script>,
@@ -2932,7 +2935,7 @@ pub struct ClosedChannel {}
 #[derive(Debug)]
 pub enum ChannelEvent {
     PeerDisconnected,
-    FundingTransactionConfirmed(BlockNumber, u32),
+    FundingTransactionConfirmed(H256, u32, u64),
     CommitmentTransactionConfirmed,
     ClosingTransactionConfirmed,
     CheckTlcSetdown,
@@ -3453,9 +3456,9 @@ impl ChannelActorState {
         let channel_update = self.generate_channel_update(network).await;
         network
             .send_message(NetworkActorMessage::new_command(
-                NetworkActorCommand::BroadcastMessages(vec![BroadcastMessage::ChannelUpdate(
-                    channel_update,
-                )]),
+                NetworkActorCommand::BroadcastMessages(vec![
+                    BroadcastMessageWithTimestamp::ChannelUpdate(channel_update),
+                ]),
             ))
             .expect(ASSUME_NETWORK_ACTOR_ALIVE);
     }
@@ -4387,6 +4390,13 @@ impl ChannelActorState {
             .expect("Funding transaction outpoint is present")
     }
 
+    pub fn must_get_funding_transaction_timestamp(&self) -> u64 {
+        self.funding_tx_confirmed_at
+            .as_ref()
+            .expect("Funding transaction confirmed at present")
+            .2
+    }
+
     pub fn get_local_shutdown_script(&self) -> Script {
         self.local_shutdown_script.clone()
     }
@@ -5384,8 +5394,11 @@ impl ChannelActorState {
             network
                 .send_message(NetworkActorMessage::new_command(
                     NetworkActorCommand::BroadcastMessages(vec![
-                        BroadcastMessage::ChannelAnnouncement(channel_announcement),
-                        BroadcastMessage::ChannelUpdate(channel_update),
+                        BroadcastMessageWithTimestamp::ChannelAnnouncement(
+                            self.must_get_funding_transaction_timestamp(),
+                            channel_announcement,
+                        ),
+                        BroadcastMessageWithTimestamp::ChannelUpdate(channel_update),
                     ]),
                 ))
                 .expect(ASSUME_NETWORK_ACTOR_ALIVE);
diff --git a/src/fiber/gossip.rs b/src/fiber/gossip.rs
index c2ba222d2..e44ce9015 100644
--- a/src/fiber/gossip.rs
+++ b/src/fiber/gossip.rs
@@ -1,7 +1,6 @@
 use std::{
     collections::{HashMap, HashSet},
     marker::PhantomData,
-    mem::take,
     sync::Arc,
     time::Duration,
 };
@@ -41,7 +40,7 @@ use super::{
     types::{
         BroadcastMessage, BroadcastMessageID, BroadcastMessageQuery, BroadcastMessageQueryFlags,
         BroadcastMessageWithTimestamp, BroadcastMessagesFilter, BroadcastMessagesFilterResult,
-        ChannelAnnouncement, ChannelUpdate, Cursor, GetBroadcastMessages,
+        ChannelAnnouncement, ChannelOnchainInfo, ChannelUpdate, Cursor, GetBroadcastMessages,
         GetBroadcastMessagesResult, GossipMessage, NodeAnnouncement, Pubkey,
         QueryBroadcastMessages, QueryBroadcastMessagesResult,
     },
@@ -324,13 +323,7 @@ pub enum GossipActorMessage {
     // Try to broadcast BroadcastMessage created by us to the network.
     // We will save and broadcast the messages. Note that we don't check the dependencies of
     // these messages because we assume that the messages created by us are always valid.
-    TryBroadcastMessages(Vec<BroadcastMessage>),
-    // Broadcast a message to the network. The message here must have all its dependencies met.
-    // This is normally the case when we saved a message to the store.
-    // This is an internal command used by both TryBroadcastMessages and ProcessBroadcastMessage,
-    // in which we will normally enrich the BroadcastMessage and check their dependencies,
-    // and then broadcast them to the network.
-    BroadcastMessageImmediately(BroadcastMessageWithTimestamp),
+    TryBroadcastMessages(Vec<BroadcastMessageWithTimestamp>),
     // Send gossip message to a peer.
     SendGossipMessage(GossipMessageWithPeerId),
     // Received GossipMessage from a peer
@@ -486,7 +479,7 @@ where
                         Some(last_message) => {
                             // We need the message timestamp to construct a valid cursor.
                             match get_message_cursor(
-                                last_message.clone(),
+                                last_message,
                                 &state.store.store,
                                 &state.chain_actor,
                             )
@@ -527,13 +520,11 @@ where
                         }
                     }
 
-                    for message in messages {
-                        let _ = state
-                            .store
-                            .actor
-                            .send_message(ExtendedGossipMessageStoreMessage::SaveMessage(message))
-                            .expect("store actor alive");
-                    }
+                    let _ = state
+                        .store
+                        .actor
+                        .send_message(ExtendedGossipMessageStoreMessage::SaveMessages(messages))
+                        .expect("store actor alive");
                     myself
                         .send_message(GossipSyncingActorMessage::NewGetRequest())
                         .expect("gossip syncing actor alive");
@@ -624,10 +615,6 @@ impl PeerFilterProcessor {
         Self { filter, actor }
     }
 
-    fn get_filter(&self) -> &Cursor {
-        &self.filter
-    }
-
     fn update_filter(&mut self, filter: &Cursor) {
         self.filter = filter.clone();
         self.actor
@@ -851,7 +838,6 @@ where
         maintenance_interval: Duration,
         announce_private_addr: bool,
         store: S,
-        gossip_actor: ActorRef<GossipActorMessage>,
         chain_actor: ActorRef<CkbChainMessage>,
         supervisor: ActorCell,
     ) -> Self {
@@ -865,7 +851,6 @@ where
                 maintenance_interval,
                 announce_private_addr,
                 store.clone(),
-                gossip_actor,
                 chain_actor,
             ),
             supervisor,
@@ -973,58 +958,49 @@ pub enum GossipMessageProcessingError {
 pub struct ExtendedGossipMessageStoreState<S> {
     announce_private_addr: bool,
     store: S,
-    gossip_actor: ActorRef<GossipActorMessage>,
     chain_actor: ActorRef<CkbChainMessage>,
     next_id: u64,
     output_ports: HashMap<u64, BroadcastMessageOutput>,
-    last_cursor: Cursor,
-    messages_to_be_saved: HashSet<BroadcastMessageWithTimestamp>,
+    messages_to_be_saved: HashSet<BroadcastMessage>,
 }
 
 impl<S: GossipMessageStore> ExtendedGossipMessageStoreState<S> {
-    fn new(
-        announce_private_addr: bool,
-        store: S,
-        gossip_actor: ActorRef<GossipActorMessage>,
-        chain_actor: ActorRef<CkbChainMessage>,
-    ) -> Self {
+    fn new(announce_private_addr: bool, store: S, chain_actor: ActorRef<CkbChainMessage>) -> Self {
         Self {
             announce_private_addr,
             store,
-            gossip_actor,
             chain_actor,
             next_id: Default::default(),
             output_ports: Default::default(),
-            last_cursor: Default::default(),
             messages_to_be_saved: Default::default(),
         }
     }
 
-    fn update_last_cursor(&mut self, cursor: Cursor) {
-        if cursor > self.last_cursor {
-            self.last_cursor = cursor;
-        }
-    }
-
-    // Saving all the messages whose transitive dependencies are already available.
-    // We will also change the relevant state (e.g. update the latest cursor).
-    // The returned list may be sent to the subscribers.
+    // Obtaining all the messages whose transitive dependencies are already available,
+    // check their validity and then save valid messages to store and
+    // return the list of saved messages that can be sent to the subscribers.
     async fn prune_messages_to_be_saved(&mut self) -> Vec<BroadcastMessageWithTimestamp> {
-        let messages_to_be_saved = take(&mut self.messages_to_be_saved);
-        let (complete_messages, uncomplete_messages) = messages_to_be_saved
+        // Note that we have to call has_dependencies_available before changing messages_to_be_saved,
+        // as the function will check the dependencies of the message in the current messages_to_be_saved.
+        let (complete_messages, incomplete_messages) = self
+            .messages_to_be_saved
+            .clone()
             .into_iter()
             .partition(|m| self.has_dependencies_available(m));
-        self.messages_to_be_saved = uncomplete_messages;
+        self.messages_to_be_saved = incomplete_messages;
 
         let mut sorted_messages = complete_messages.into_iter().collect::<Vec<_>>();
         sorted_messages.sort_unstable();
+        trace!(
+            "Saving complete messages to the store: {:?}",
+            &sorted_messages
+        );
 
         let mut verified_sorted_messages = Vec::with_capacity(sorted_messages.len());
         for message in sorted_messages {
             match verify_and_save_broadcast_message(&message, &self.store, &self.chain_actor).await
             {
-                Ok(_) => {
-                    self.update_last_cursor(message.cursor());
+                Ok(message) => {
                     verified_sorted_messages.push(message);
                 }
                 Err(error) => {
@@ -1040,21 +1016,71 @@ impl<S: GossipMessageStore> ExtendedGossipMessageStoreState<S> {
         verified_sorted_messages
     }
 
-    fn get_channel_annnouncement(&self, outpoint: &OutPoint) -> Option<(u64, ChannelAnnouncement)> {
+    fn store_messages(&mut self, messages: &[BroadcastMessageWithTimestamp]) {
+        for message in messages {
+            match message {
+                BroadcastMessageWithTimestamp::ChannelAnnouncement(
+                    timestamp,
+                    channel_announcement,
+                ) => {
+                    self.store
+                        .save_channel_announcement(*timestamp, channel_announcement.clone());
+                }
+                BroadcastMessageWithTimestamp::ChannelUpdate(channel_update) => {
+                    self.store.save_channel_update(channel_update.clone());
+                }
+                BroadcastMessageWithTimestamp::NodeAnnouncement(node_announcement) => {
+                    self.store.save_node_announcement(node_announcement.clone());
+                }
+            }
+        }
+    }
+
+    fn broadcast_messages(&mut self, messages: &[BroadcastMessageWithTimestamp]) {
+        if messages.is_empty() {
+            return;
+        }
+
+        for (id, subscription) in self.output_ports.iter() {
+            let messages_to_send = messages
+                .iter()
+                .filter(|m| &m.cursor() > &subscription.filter)
+                .cloned()
+                .collect::<Vec<_>>();
+            trace!(
+                "Sending complete messages in memory to subscription #{}: number of messages = {}",
+                id,
+                messages_to_send.len()
+            );
+            for chunk in messages_to_send.chunks(MAX_NUM_OF_BROADCAST_MESSAGES as usize) {
+                subscription
+                    .output_port
+                    .send(GossipMessageUpdates::new(chunk.to_vec()));
+            }
+        }
+    }
+
+    fn store_and_broadcast_messages(&mut self, messages: &[BroadcastMessageWithTimestamp]) {
+        self.store_messages(messages);
+        self.broadcast_messages(messages);
+    }
+
+    fn get_channel_annnouncement(&self, outpoint: &OutPoint) -> Option<ChannelAnnouncement> {
         self.store
             .get_latest_channel_announcement(outpoint)
+            .map(|(_, m)| m)
             .or_else(|| self.get_channel_annnouncement_in_memory(outpoint))
     }
 
     fn get_channel_annnouncement_in_memory(
         &self,
         outpoint: &OutPoint,
-    ) -> Option<(u64, ChannelAnnouncement)> {
+    ) -> Option<ChannelAnnouncement> {
         self.messages_to_be_saved.iter().find_map(|m| match m {
-            BroadcastMessageWithTimestamp::ChannelAnnouncement(timestamp, channel_announcement)
+            BroadcastMessage::ChannelAnnouncement(channel_announcement)
                 if &channel_announcement.channel_outpoint == outpoint =>
             {
-                Some((*timestamp, channel_announcement.clone()))
+                Some(channel_announcement.clone())
             }
             _ => None,
         })
@@ -1063,34 +1089,33 @@ impl<S: GossipMessageStore> ExtendedGossipMessageStoreState<S> {
     async fn insert_message_to_be_saved_list(
         &mut self,
         message: &BroadcastMessage,
-    ) -> Result<BroadcastMessageWithTimestamp, GossipMessageProcessingError> {
+    ) -> Result<(), GossipMessageProcessingError> {
         if let Some(existing_message) = get_existing_newer_broadcast_message(message, &self.store) {
             if &BroadcastMessage::from(existing_message.clone()) != message {
                 return Err(GossipMessageProcessingError::NewerMessageSaved(
                     existing_message,
                 ));
             } else {
-                return Ok(existing_message);
+                return Ok(());
             }
         }
 
-        let message =
-            get_broadcast_message_with_timestamp(message.clone(), &self.store, &self.chain_actor)
-                .await
-                .map_err(|error| {
-                    GossipMessageProcessingError::ProcessingError(error.to_string())
-                })?;
-
-        let max_acceptable_gossip_message_timestamp = max_acceptable_gossip_message_timestamp();
-        if message.timestamp() > max_acceptable_gossip_message_timestamp {
-            return Err(GossipMessageProcessingError::MessageTooNew(
-                message.timestamp(),
-                max_acceptable_gossip_message_timestamp,
-            ));
+        if self.messages_to_be_saved.contains(&message) {
+            return Ok(());
+        }
+
+        if let Some(timestamp) = message.timestamp() {
+            let max_acceptable_gossip_message_timestamp = max_acceptable_gossip_message_timestamp();
+            if timestamp > max_acceptable_gossip_message_timestamp {
+                return Err(GossipMessageProcessingError::MessageTooNew(
+                    timestamp,
+                    max_acceptable_gossip_message_timestamp,
+                ));
+            }
         }
 
         if !self.announce_private_addr {
-            if let BroadcastMessageWithTimestamp::NodeAnnouncement(node_announcement) = &message {
+            if let BroadcastMessage::NodeAnnouncement(node_announcement) = &message {
                 if !node_announcement.addresses.iter().any(|addr| {
                     multiaddr_to_socketaddr(addr)
                         .map(|socket_addr| is_reachable(socket_addr.ip()))
@@ -1105,12 +1130,12 @@ impl<S: GossipMessageStore> ExtendedGossipMessageStoreState<S> {
 
         trace!("New gossip message saved to memory: {:?}", message);
         self.messages_to_be_saved.insert(message.clone());
-        Ok(message)
+        Ok(())
     }
 
-    fn has_dependencies_available(&self, message: &BroadcastMessageWithTimestamp) -> bool {
+    fn has_dependencies_available(&self, message: &BroadcastMessage) -> bool {
         match message {
-            BroadcastMessageWithTimestamp::ChannelUpdate(channel_update) => self
+            BroadcastMessage::ChannelUpdate(channel_update) => self
                 .get_channel_annnouncement(&channel_update.channel_outpoint)
                 .is_some(),
             _ => true,
@@ -1142,13 +1167,7 @@ impl<S: GossipMessageStore> ExtendedGossipMessageStoreActor<S> {
 impl<S: GossipMessageStore + Send + Sync + 'static> Actor for ExtendedGossipMessageStoreActor<S> {
     type Msg = ExtendedGossipMessageStoreMessage;
     type State = ExtendedGossipMessageStoreState<S>;
-    type Arguments = (
-        Duration,
-        bool,
-        S,
-        ActorRef<GossipActorMessage>,
-        ActorRef<CkbChainMessage>,
-    );
+    type Arguments = (Duration, bool, S, ActorRef<CkbChainMessage>);
 
     async fn pre_start(
         &self,
@@ -1157,7 +1176,6 @@ impl<S: GossipMessageStore + Send + Sync + 'static> Actor for ExtendedGossipMess
             gossip_store_maintenance_interval,
             announce_private_addr,
             store,
-            gossip_actor,
             chain_actor,
         ): Self::Arguments,
     ) -> Result<Self::State, ActorProcessingErr> {
@@ -1167,7 +1185,6 @@ impl<S: GossipMessageStore + Send + Sync + 'static> Actor for ExtendedGossipMess
         Ok(ExtendedGossipMessageStoreState::new(
             announce_private_addr,
             store,
-            gossip_actor,
             chain_actor,
         ))
     }
@@ -1273,59 +1290,28 @@ impl<S: GossipMessageStore + Send + Sync + 'static> Actor for ExtendedGossipMess
                 }
             }
 
-            ExtendedGossipMessageStoreMessage::SaveMessage(message) => {
-                if let Err(error) = state.insert_message_to_be_saved_list(&message).await {
-                    trace!("Failed to save message: {:?}, error: {:?}", message, error);
+            ExtendedGossipMessageStoreMessage::SaveMessages(messages) => {
+                for message in messages {
+                    if let Err(error) = state.insert_message_to_be_saved_list(&message).await {
+                        trace!("Failed to save message: {:?}, error: {:?}", message, error);
+                    }
                 }
             }
 
-            ExtendedGossipMessageStoreMessage::SaveAndBroadcastMessage(message) => {
-                match state.insert_message_to_be_saved_list(&message).await {
-                    Err(error) => error!(
-                        "Failed to save message and broadcast message: {:?}, error: {:?}",
-                        message, error
-                    ),
-                    Ok(message) => {
-                        // Normally we will need to check if the message has any dependencies that are not saved yet.
-                        // But this is not necessary for the messages that we are proactively broadcasting.
-                        // These are our own channel announcements, channel updates and node announcements.
-                        let _ = state
-                            .gossip_actor
-                            .send_message(GossipActorMessage::BroadcastMessageImmediately(message));
-                    }
-                }
+            ExtendedGossipMessageStoreMessage::SaveAndBroadcastMessages(messages) => {
+                state.store_and_broadcast_messages(&messages);
             }
 
             ExtendedGossipMessageStoreMessage::Tick => {
                 trace!(
-                    "Gossip store maintenance ticked: last_cursor = {:?} #subscriptions = {},  #messages_to_be_saved = {}",
-                    state.last_cursor,
+                    "Gossip store maintenance ticked: #subscriptions = {},  #messages_to_be_saved = {}",
                     state.output_ports.len(),
                     state.messages_to_be_saved.len(),
                 );
 
                 // These are the messages that have complete dependencies and can be sent to the subscribers.
                 let complete_messages = state.prune_messages_to_be_saved().await;
-                if complete_messages.is_empty() {
-                    return Ok(());
-                }
-                for (id, subscription) in state.output_ports.iter() {
-                    let messages_to_send = complete_messages
-                        .iter()
-                        .filter(|m| &m.cursor() > &subscription.filter)
-                        .cloned()
-                        .collect::<Vec<_>>();
-                    trace!(
-                        "Sending complete messages in memory to subscription #{}: number of messages = {}",
-                        id,
-                        messages_to_send.len()
-                    );
-                    for chunk in messages_to_send.chunks(MAX_NUM_OF_BROADCAST_MESSAGES as usize) {
-                        subscription
-                            .output_port
-                            .send(GossipMessageUpdates::new(chunk.to_vec()));
-                    }
-                }
+                state.broadcast_messages(&complete_messages);
             }
         }
         Ok(())
@@ -1346,22 +1332,19 @@ pub enum ExtendedGossipMessageStoreMessage {
     // Update the subscription. If this Option is None, the subscription will be cancelled.
     // Otherwise the new cursor will be used to filter the messages that are sent to the subscriber.
     UpdateSubscription(u64, Option<Cursor>, RpcReplyPort<()>),
-    // Save a new broadcast message to the store. We will check if the message has any dependencies that are not
-    // saved yet. If it has, we will save it to messages_to_be_saved, otherwise we will save it to the store.
-    // We may also save the message to lagged_messages if the message is lagged.
-    // We may pass a bool parameter to indicate if a output port to wait for the message to be saved should be
-    // returned. If there is any error while saving the message, we will send an error message to the output port.
-    SaveMessage(BroadcastMessage),
-    // Save a new message to the store. If the message's dependencies are all met, then we will
-    // broadcast the message to the network. Otherwise, we will ignore the broadcasting.
-    SaveAndBroadcastMessage(BroadcastMessage),
+    // Save new broadcast messages to the store. The messages will be first saved to the memory,
+    // then if all the dependencies are met, they are periodically saved to the store and sent to the subscribers.
+    SaveMessages(Vec<BroadcastMessage>),
+    // Save new messages to the store, and broadcast them to the subscribers immediately.
+    // These messages will not be saved to the memory and wait for the dependencies to be met.
+    // We normally use this variant to send our own messages to the subscribers.
+    SaveAndBroadcastMessages(Vec<BroadcastMessageWithTimestamp>),
     // Send broadcast messages after the cursor to the subscriber specified in the u64 id.
     // This is normally called immediately after a new subscription is created. This is the time when
     // we need to send existing messages to the subscriber.
     LoadMessagesFromStore(u64, Cursor),
     // A tick message that is sent periodically to check if there are any messages that are saved out of order.
     // If there are, we will send them to the subscribers.
-    // This tick will also advance the last_cursor upon finishing.
     Tick,
 }
 
@@ -1616,7 +1599,9 @@ where
         let _ = self
             .store
             .actor
-            .send_message(ExtendedGossipMessageStoreMessage::SaveMessage(message))
+            .send_message(ExtendedGossipMessageStoreMessage::SaveMessages(vec![
+                message,
+            ]))
             .expect("store actor alive");
     }
 
@@ -1709,12 +1694,30 @@ fn get_dependent_message_queries<S: GossipMessageStore>(
 }
 
 async fn get_message_cursor<S: GossipMessageStore>(
-    message: BroadcastMessage,
+    message: &BroadcastMessage,
     store: &S,
     chain: &ActorRef<CkbChainMessage>,
 ) -> Result<Cursor, Error> {
-    let m = get_broadcast_message_with_timestamp(message, store, chain).await?;
-    Ok(m.cursor())
+    match message {
+        BroadcastMessage::ChannelAnnouncement(channel_announcement) => {
+            let timestamp =
+                get_channel_timestamp(&channel_announcement.channel_outpoint, store, chain).await?;
+            Ok(Cursor::new(
+                timestamp,
+                BroadcastMessageID::ChannelAnnouncement(
+                    channel_announcement.channel_outpoint.clone(),
+                ),
+            ))
+        }
+        BroadcastMessage::ChannelUpdate(channel_update) => Ok(Cursor::new(
+            channel_update.timestamp,
+            BroadcastMessageID::ChannelUpdate(channel_update.channel_outpoint.clone()),
+        )),
+        BroadcastMessage::NodeAnnouncement(node_announcement) => Ok(Cursor::new(
+            node_announcement.timestamp,
+            BroadcastMessageID::NodeAnnouncement(node_announcement.node_id.clone()),
+        )),
+    }
 }
 
 fn get_existing_broadcast_message<S: GossipMessageStore>(
@@ -1755,60 +1758,42 @@ fn get_existing_newer_broadcast_message<S: GossipMessageStore>(
     })
 }
 
-async fn get_broadcast_message_with_timestamp<S: GossipMessageStore>(
-    message: BroadcastMessage,
+// Verify and save broadcast messages to the store.
+// Note that we can't relialy verify a message until we have all the messages that it depends on.
+// So this function should be called by the dependency order of the messages.
+// E.g. channel updates depends on channel announcements to obtain the node public keys,
+// so we should call this method to save and verify channel announcements before channel updates.
+async fn verify_and_save_broadcast_message<S: GossipMessageStore>(
+    message: &BroadcastMessage,
     store: &S,
     chain: &ActorRef<CkbChainMessage>,
 ) -> Result<BroadcastMessageWithTimestamp, Error> {
-    match message {
+    let timestamp = match message {
         BroadcastMessage::ChannelAnnouncement(channel_announcement) => {
-            let timestamp =
-                get_channel_timestamp(&channel_announcement.channel_outpoint, store, chain).await?;
-            Ok(BroadcastMessageWithTimestamp::ChannelAnnouncement(
-                timestamp,
-                channel_announcement,
-            ))
-        }
-        BroadcastMessage::ChannelUpdate(channel_update) => {
-            Ok(BroadcastMessageWithTimestamp::ChannelUpdate(channel_update))
-        }
-        BroadcastMessage::NodeAnnouncement(node_announcement) => Ok(
-            BroadcastMessageWithTimestamp::NodeAnnouncement(node_announcement),
-        ),
-    }
-}
-
-// Channel updates depends on channel announcements to obtain the node public keys.
-// If a channel update is saved before the channel announcement, we can't reliably determine if
-// this channel update is valid. So we need to save the channel update to lagged_messages and
-// wait for the channel announcement to be saved. The bool value returned indicates if the
-// message is fully verified and can be saved to the store.
-// In the same vein, channel announcement contains references to node announcements. If a node
-// announcement is saved before the channel announcement, we need to temporarily save the channel
-// announcement to lagged_messages and wait for the node announcement to be saved.
-async fn verify_and_save_broadcast_message<S: GossipMessageStore>(
-    message: &BroadcastMessageWithTimestamp,
-    store: &S,
-    chain: &ActorRef<CkbChainMessage>,
-) -> Result<(), Error> {
-    match message {
-        BroadcastMessageWithTimestamp::ChannelAnnouncement(timestamp, channel_announcement) => {
-            if !verify_channel_announcement(channel_announcement, store, chain).await? {
-                store.save_channel_announcement(*timestamp, channel_announcement.clone());
+            let on_chain_info =
+                get_channel_on_chain_info(channel_announcement.out_point(), chain).await?;
+            if !verify_channel_announcement(channel_announcement, &on_chain_info, store).await? {
+                store.save_channel_announcement(
+                    on_chain_info.timestamp,
+                    channel_announcement.clone(),
+                );
             }
+            on_chain_info.timestamp
         }
-        BroadcastMessageWithTimestamp::ChannelUpdate(channel_update) => {
+        BroadcastMessage::ChannelUpdate(channel_update) => {
             if !verify_channel_update(channel_update, store)? {
                 store.save_channel_update(channel_update.clone());
             }
+            channel_update.timestamp
         }
-        BroadcastMessageWithTimestamp::NodeAnnouncement(node_announcement) => {
+        BroadcastMessage::NodeAnnouncement(node_announcement) => {
             if !verify_node_announcement(node_announcement, store)? {
                 store.save_node_announcement(node_announcement.clone());
             }
+            node_announcement.timestamp
         }
-    }
-    Ok(())
+    };
+    Ok((message.clone(), timestamp).into())
 }
 
 async fn get_channel_tx(
@@ -1821,7 +1806,7 @@ async fn get_channel_tx(
         DEFAULT_CHAIN_ACTOR_TIMEOUT,
         TraceTxRequest {
             tx_hash: outpoint.tx_hash(),
-            confirmations: 1,
+            confirmations: 2,
         }
     ) {
         Ok(TraceTxResponse {
@@ -1850,7 +1835,26 @@ async fn get_channel_timestamp<S: GossipMessageStore>(
         return Ok(timestamp);
     }
 
-    let (_, block_hash) = get_channel_tx(outpoint, chain).await?;
+    let on_chain_info = get_channel_on_chain_info(outpoint, chain).await?;
+
+    Ok(on_chain_info.timestamp)
+}
+
+async fn get_channel_on_chain_info(
+    outpoint: &OutPoint,
+    chain: &ActorRef<CkbChainMessage>,
+) -> Result<ChannelOnchainInfo, Error> {
+    let (tx, block_hash) = get_channel_tx(outpoint, chain).await?;
+    let first_output = match tx.inner.outputs.first() {
+        None => {
+            return Err(Error::InvalidParameter(format!(
+                "On-chain transaction found but no output: {:?}",
+                &outpoint
+            )));
+        }
+        Some(output) => output.clone(),
+    };
+
     let timestamp: u64 = match call_t!(
         chain,
         CkbChainMessage::GetBlockTimestamp,
@@ -1878,7 +1882,10 @@ async fn get_channel_timestamp<S: GossipMessageStore>(
         }
     };
 
-    Ok(timestamp)
+    Ok(ChannelOnchainInfo {
+        timestamp,
+        first_output,
+    })
 }
 
 // Verify the channel announcement message. If any error occurs, return the error.
@@ -1887,8 +1894,8 @@ async fn get_channel_timestamp<S: GossipMessageStore>(
 // is true, otherwise it is false.
 async fn verify_channel_announcement<S: GossipMessageStore>(
     channel_announcement: &ChannelAnnouncement,
+    on_chain_info: &ChannelOnchainInfo,
     store: &S,
-    chain: &ActorRef<CkbChainMessage>,
 ) -> Result<bool, Error> {
     if let Some((_, announcement)) =
         store.get_latest_channel_announcement(&channel_announcement.channel_outpoint)
@@ -1945,37 +1952,32 @@ async fn verify_channel_announcement<S: GossipMessageStore>(
         )));
     }
 
-    let (tx, _) = get_channel_tx(&channel_announcement.channel_outpoint, chain).await?;
     let pubkey = channel_announcement.ckb_key.serialize();
     let pubkey_hash = &blake2b_256(pubkey.as_slice())[0..20];
-    match tx.inner.outputs.first() {
-        None => {
-            return Err(Error::InvalidParameter(format!(
-                "On-chain transaction found but no output: {:?}",
-                &channel_announcement
-            )));
-        }
-        Some(output) => {
-            if output.lock.args.as_bytes() != pubkey_hash {
-                return Err(Error::InvalidParameter(format!(
+
+    let output = &on_chain_info.first_output;
+    if output.lock.args.as_bytes() != pubkey_hash {
+        return Err(Error::InvalidParameter(format!(
                     "On-chain transaction found but pubkey hash mismatched: on chain hash {:?}, pub key ({:?}) hash {:?}",
                     &output.lock.args.as_bytes(),
                     hex::encode(pubkey),
                     &pubkey_hash
                 )));
-            }
-            let capacity: u128 = u64::from(output.capacity).into();
-            if channel_announcement.udt_type_script.is_none()
-                && channel_announcement.capacity > capacity
-            {
+    }
+    let capacity: u128 = u64::from(output.capacity).into();
+    match channel_announcement.udt_type_script {
+        Some(_) => {
+            // TODO: verify the capacity of the UDT
+        }
+        None => {
+            if channel_announcement.capacity > capacity {
                 return Err(Error::InvalidParameter(format!(
-                    "On-chain transaction found but capacity mismatched: on chain capacity {:?} smaller than annoucned channel capacity {:?}",
-                    &output.capacity, &channel_announcement.capacity
-                )));
+                            "On-chain transaction found but capacity mismatched: on chain capacity {:?} smaller than annoucned channel capacity {:?}",
+                            &output.capacity, &channel_announcement.capacity
+                        )));
             }
-            capacity
         }
-    };
+    }
 
     if let Err(err) = secp256k1_instance().verify_schnorr(
         ckb_signature,
@@ -2173,7 +2175,6 @@ where
             store_maintenance_interval,
             announce_private_addr,
             store,
-            myself.clone(),
             chain_actor.clone(),
             myself.get_cell(),
         )
@@ -2260,43 +2261,14 @@ where
                     .await?;
             }
             GossipActorMessage::TryBroadcastMessages(messages) => {
-                for message in messages {
-                    state
-                        .store
-                        .actor
-                        .send_message(ExtendedGossipMessageStoreMessage::SaveAndBroadcastMessage(
-                            message.clone(),
-                        ))
-                        .expect("store actor alive");
-                }
-            }
-            GossipActorMessage::BroadcastMessageImmediately(message) => {
-                for (peer, peer_state) in &state.peer_states {
-                    let session = peer_state.session_id;
-                    match &peer_state.filter_processor {
-                        Some(filter_processor)
-                            if filter_processor.get_filter() < &message.cursor() =>
-                        {
-                            trace!("Broadcasting message to peer {:?}: {:?}", &peer, &message);
-                            state
-                                .send_message_to_session(
-                                    session,
-                                    GossipMessage::BroadcastMessagesFilterResult(
-                                        message.create_broadcast_messages_filter_result(),
-                                    ),
-                                )
-                                .await?;
-                        }
-                        _ => {
-                            debug!(
-                                "Ignoring broadcast message for peer {:?}: {:?} as its filter processor is {:?}",
-                                peer, &message, &peer_state.filter_processor
-                            );
-                        }
-                    }
-                }
+                state
+                    .store
+                    .actor
+                    .send_message(ExtendedGossipMessageStoreMessage::SaveAndBroadcastMessages(
+                        messages,
+                    ))
+                    .expect("store actor alive");
             }
-
             GossipActorMessage::RotateOutboundPassiveSyncingPeers => {
                 if !state.is_ready_for_passive_syncing() {
                     return Ok(());
diff --git a/src/fiber/network.rs b/src/fiber/network.rs
index d504c05d9..2b84d8d0b 100644
--- a/src/fiber/network.rs
+++ b/src/fiber/network.rs
@@ -1,8 +1,9 @@
 use ckb_hash::blake2b_256;
-use ckb_jsonrpc_types::{BlockNumber, Status, TxStatus};
+use ckb_jsonrpc_types::{Status, TxStatus};
 use ckb_types::core::{EpochNumberWithFraction, TransactionView};
 use ckb_types::packed::{Byte32, OutPoint, Script, Transaction};
 use ckb_types::prelude::{IntoTransactionView, Pack, Unpack};
+use ckb_types::H256;
 use once_cell::sync::OnceCell;
 use ractor::concurrency::Duration;
 use ractor::{
@@ -59,15 +60,18 @@ use super::gossip::{GossipActorMessage, GossipMessageStore, GossipMessageUpdates
 use super::graph::{NetworkGraph, NetworkGraphStateStore, SessionRoute};
 use super::key::blake2b_hash_with_salt;
 use super::types::{
-    BroadcastMessage, BroadcastMessageQuery, EcdsaSignature, FiberMessage, GossipMessage, Hash256,
-    NodeAnnouncement, OpenChannel, PaymentHopData, Privkey, Pubkey, RemoveTlcReason, TlcErr,
-    TlcErrData, TlcErrorCode,
+    BroadcastMessage, BroadcastMessageQuery, BroadcastMessageWithTimestamp, EcdsaSignature,
+    FiberMessage, GossipMessage, Hash256, NodeAnnouncement, OpenChannel, PaymentHopData, Privkey,
+    Pubkey, RemoveTlcReason, TlcErr, TlcErrData, TlcErrorCode,
 };
 use super::{FiberConfig, ASSUME_NETWORK_ACTOR_ALIVE};
 
 use crate::ckb::config::UdtCfgInfos;
 use crate::ckb::contracts::{check_udt_script, get_udt_whitelist, is_udt_type_auto_accept};
-use crate::ckb::{CkbChainMessage, FundingRequest, FundingTx, TraceTxRequest, TraceTxResponse};
+use crate::ckb::{
+    CkbChainMessage, FundingRequest, FundingTx, GetBlockTimestampRequest, TraceTxRequest,
+    TraceTxResponse,
+};
 use crate::fiber::channel::{
     AddTlcCommand, AddTlcResponse, TxCollaborationCommand, TxUpdateCommand,
 };
@@ -227,7 +231,7 @@ pub enum NetworkActorCommand {
     // we use this to query them.
     QueryBroadcastMessages(PeerId, Vec<BroadcastMessageQuery>),
     // Broadcast our BroadcastMessage to the network.
-    BroadcastMessages(Vec<BroadcastMessage>),
+    BroadcastMessages(Vec<BroadcastMessageWithTimestamp>),
     // Broadcast local information to the network.
     BroadcastLocalInfo(LocalInfoKind),
     SignMessage([u8; 32], RpcReplyPort<EcdsaSignature>),
@@ -598,8 +602,8 @@ pub enum NetworkActorEvent {
     FundingTransactionPending(Transaction, OutPoint, Hash256),
 
     /// A funding transaction has been confirmed. The transaction was included in the
-    /// block with the given transaction index.
-    FundingTransactionConfirmed(OutPoint, BlockNumber, u32),
+    /// block with the given transaction index, and the timestamp in the block header.
+    FundingTransactionConfirmed(OutPoint, H256, u32, u64),
 
     /// A funding transaction has failed.
     FundingTransactionFailed(OutPoint),
@@ -857,9 +861,14 @@ where
                     .on_funding_transaction_pending(transaction, outpoint.clone(), channel_id)
                     .await;
             }
-            NetworkActorEvent::FundingTransactionConfirmed(outpoint, block_number, tx_index) => {
+            NetworkActorEvent::FundingTransactionConfirmed(
+                outpoint,
+                block_hash,
+                tx_index,
+                timestamp,
+            ) => {
                 state
-                    .on_funding_transaction_confirmed(outpoint, block_number, tx_index)
+                    .on_funding_transaction_confirmed(outpoint, block_hash, tx_index, timestamp)
                     .await;
             }
             NetworkActorEvent::CommitmentTransactionPending(transaction, channel_id) => {
@@ -1305,7 +1314,7 @@ where
                     myself
                         .send_message(NetworkActorMessage::new_command(
                             NetworkActorCommand::BroadcastMessages(vec![
-                                BroadcastMessage::NodeAnnouncement(message),
+                                BroadcastMessageWithTimestamp::NodeAnnouncement(message),
                             ]),
                         ))
                         .expect(ASSUME_NETWORK_MYSELF_ALIVE);
@@ -2441,9 +2450,9 @@ where
                 remote_peer_id, &message
             );
             let _ = self.network.send_message(NetworkActorMessage::new_command(
-                NetworkActorCommand::BroadcastMessages(vec![BroadcastMessage::NodeAnnouncement(
-                    message,
-                )]),
+                NetworkActorCommand::BroadcastMessages(vec![
+                    BroadcastMessageWithTimestamp::NodeAnnouncement(message),
+                ]),
             ));
         } else {
             debug!(
@@ -2662,41 +2671,80 @@ where
             &outpoint, &channel_id, &tx_hash
         );
         let network = self.network.clone();
+        let chain = self.chain_actor.clone();
         self.broadcast_tx_with_callback(transaction, move |result| {
-            let message = match result {
+            match result {
                 Ok(TraceTxResponse {
                     status:
                         TxStatus {
                             status: Status::Committed,
-                            block_number: Some(block_number),
+                            block_hash: Some(block_hash),
                             ..
                         },
                     ..
                 }) => {
-                    info!("Funding transaction {:?} confirmed", &tx_hash);
-                    NetworkActorEvent::FundingTransactionConfirmed(
-                        outpoint,
-                        block_number.into(),
-                        DUMMY_FUNDING_TX_INDEX,
-                    )
+                    tokio::spawn( async move  {
+                        match call!(
+                            chain,
+                            |reply| CkbChainMessage::GetBlockTimestamp(
+                                GetBlockTimestampRequest::from_block_hash(block_hash.clone()), reply
+                            )
+                        ) {
+                            Ok(Ok(Some(timestamp))) => {
+                                info!("Funding transaction {:?} confirmed", &tx_hash);
+                                // Notify outside observers.
+                                network.send_message(NetworkActorMessage::new_event(
+                                    NetworkActorEvent::FundingTransactionConfirmed(
+                                        outpoint.clone(),
+                                        block_hash.clone(),
+                                        DUMMY_FUNDING_TX_INDEX,
+                                        timestamp,
+                                    )
+                                ))
+                                .expect(ASSUME_NETWORK_MYSELF_ALIVE);
+                                return;
+                            },
+                            Ok(Ok(None)) => {
+                                error!(
+                                    "Failed to get block timestamp for block hash {:?}: block not found",
+                                    &block_hash
+                                );
+                            }
+                            Ok(Err(err)) => {
+                                error!(
+                                    "Failed to get block timestamp for block hash {:?}: {:?}",
+                                    &block_hash, &err
+                                );
+                            }
+                            Err(err) => {
+                                error!(
+                                    "Failed to get block timestamp for block hash {:?}: {:?}",
+                                    &block_hash, &err
+                                );
+                            }
+                        }
+                    });
                 }
                 Ok(status) => {
                     error!(
                         "Funding transaction {:?} failed to be confirmed with final status {:?}",
                         &tx_hash, &status
                     );
-                    NetworkActorEvent::FundingTransactionFailed(outpoint)
+                    // Notify outside observers.
+                    network
+                        .send_message(NetworkActorMessage::new_event(                    NetworkActorEvent::FundingTransactionFailed(outpoint)
+                    ))
+                        .expect(ASSUME_NETWORK_MYSELF_ALIVE);
                 }
                 Err(err) => {
                     error!("Failed to trace transaction {:?}: {:?}", &tx_hash, &err);
-                    NetworkActorEvent::FundingTransactionFailed(outpoint)
+                    // Notify outside observers.
+                    network
+                        .send_message(NetworkActorMessage::new_event(                    NetworkActorEvent::FundingTransactionFailed(outpoint)
+                    ))
+                        .expect(ASSUME_NETWORK_MYSELF_ALIVE);
                 }
             };
-
-            // Notify outside observers.
-            network
-                .send_message(NetworkActorMessage::new_event(message))
-                .expect(ASSUME_NETWORK_MYSELF_ALIVE);
         })
         .await;
     }
@@ -2752,8 +2800,9 @@ where
     async fn on_funding_transaction_confirmed(
         &mut self,
         outpoint: OutPoint,
-        block_number: BlockNumber,
+        block_hash: H256,
         tx_index: u32,
+        timestamp: u64,
     ) {
         debug!("Funding transaction is confirmed: {:?}", &outpoint);
         let channel_id = match self.pending_channels.remove(&outpoint) {
@@ -2770,8 +2819,7 @@ where
             channel_id,
             None,
             ChannelActorMessage::Event(ChannelEvent::FundingTransactionConfirmed(
-                block_number,
-                tx_index,
+                block_hash, tx_index, timestamp,
             )),
         )
         .await;
diff --git a/src/fiber/tests/gossip.rs b/src/fiber/tests/gossip.rs
index c3dd3c48f..26c7d8854 100644
--- a/src/fiber/tests/gossip.rs
+++ b/src/fiber/tests/gossip.rs
@@ -114,7 +114,9 @@ impl GossipTestingContext {
 
     fn save_message(&self, message: BroadcastMessage) {
         self.get_store_actor()
-            .send_message(ExtendedGossipMessageStoreMessage::SaveMessage(message))
+            .send_message(ExtendedGossipMessageStoreMessage::SaveMessages(vec![
+                message,
+            ]))
             .expect("send message");
     }
 
diff --git a/src/fiber/types.rs b/src/fiber/types.rs
index 71e68590f..b4f1d5c4d 100644
--- a/src/fiber/types.rs
+++ b/src/fiber/types.rs
@@ -11,6 +11,7 @@ use super::r#gen::fiber::PubNonceOpt;
 use super::serde_utils::{EntityHex, SliceHex};
 use crate::ckb::config::{UdtArgInfo, UdtCellDep, UdtCfgInfos, UdtScript};
 use crate::ckb::contracts::get_udt_whitelist;
+use ckb_jsonrpc_types::CellOutput;
 use num_enum::IntoPrimitive;
 use num_enum::TryFromPrimitive;
 use std::convert::TryFrom;
@@ -2440,8 +2441,41 @@ impl BroadcastMessage {
             }
         }
     }
+
+    pub(crate) fn message_id(&self) -> BroadcastMessageID {
+        match self {
+            BroadcastMessage::NodeAnnouncement(node_announcement) => {
+                BroadcastMessageID::NodeAnnouncement(node_announcement.node_id)
+            }
+            BroadcastMessage::ChannelAnnouncement(channel_announcement) => {
+                BroadcastMessageID::ChannelAnnouncement(
+                    channel_announcement.channel_outpoint.clone(),
+                )
+            }
+            BroadcastMessage::ChannelUpdate(channel_update) => {
+                BroadcastMessageID::ChannelUpdate(channel_update.channel_outpoint.clone())
+            }
+        }
+    }
+
+    pub(crate) fn timestamp(&self) -> Option<u64> {
+        match self {
+            BroadcastMessage::NodeAnnouncement(node_announcement) => {
+                Some(node_announcement.timestamp)
+            }
+            BroadcastMessage::ChannelAnnouncement(_) => None,
+            BroadcastMessage::ChannelUpdate(channel_update) => Some(channel_update.timestamp),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ChannelOnchainInfo {
+    pub timestamp: u64,
+    pub first_output: CellOutput,
 }
 
+// Augment the broadcast message with timestamp so that we can easily obtain the cursor of the message.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum BroadcastMessageWithTimestamp {
     NodeAnnouncement(NodeAnnouncement),
@@ -2520,7 +2554,7 @@ impl BroadcastMessageWithTimestamp {
     }
 }
 
-impl Ord for BroadcastMessageWithTimestamp {
+impl Ord for BroadcastMessage {
     fn cmp(&self, other: &Self) -> Ordering {
         self.message_id()
             .cmp(&other.message_id())
@@ -2528,12 +2562,33 @@ impl Ord for BroadcastMessageWithTimestamp {
     }
 }
 
-impl PartialOrd for BroadcastMessageWithTimestamp {
+impl PartialOrd for BroadcastMessage {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 
+impl From<(BroadcastMessage, Option<ChannelOnchainInfo>)> for BroadcastMessageWithTimestamp {
+    fn from(
+        (broadcast_message, channel_onchain_info): (BroadcastMessage, Option<ChannelOnchainInfo>),
+    ) -> Self {
+        match broadcast_message {
+            BroadcastMessage::NodeAnnouncement(node_announcement) => {
+                BroadcastMessageWithTimestamp::NodeAnnouncement(node_announcement)
+            }
+            BroadcastMessage::ChannelAnnouncement(channel_announcement) => {
+                let timestamp = channel_onchain_info
+                    .expect("Channel onchain info is required for channel announcement")
+                    .timestamp;
+                BroadcastMessageWithTimestamp::ChannelAnnouncement(timestamp, channel_announcement)
+            }
+            BroadcastMessage::ChannelUpdate(channel_update) => {
+                BroadcastMessageWithTimestamp::ChannelUpdate(channel_update)
+            }
+        }
+    }
+}
+
 impl From<BroadcastMessageWithTimestamp> for BroadcastMessage {
     fn from(broadcast_message_with_timestamp: BroadcastMessageWithTimestamp) -> Self {
         match broadcast_message_with_timestamp {
@@ -2720,14 +2775,14 @@ impl Ord for BroadcastMessageID {
                 BroadcastMessageID::NodeAnnouncement(pubkey1),
                 BroadcastMessageID::NodeAnnouncement(pubkey2),
             ) => pubkey1.cmp(pubkey2),
-            (BroadcastMessageID::ChannelUpdate(_), _) => Ordering::Less,
-            (BroadcastMessageID::NodeAnnouncement(_), _) => Ordering::Greater,
+            (BroadcastMessageID::NodeAnnouncement(_), _) => Ordering::Less,
+            (BroadcastMessageID::ChannelUpdate(_), _) => Ordering::Greater,
             (
                 BroadcastMessageID::ChannelAnnouncement(_),
                 BroadcastMessageID::NodeAnnouncement(_),
-            ) => Ordering::Less,
+            ) => Ordering::Greater,
             (BroadcastMessageID::ChannelAnnouncement(_), BroadcastMessageID::ChannelUpdate(_)) => {
-                Ordering::Greater
+                Ordering::Less
             }
         }
     }
diff --git a/src/store/tests/store.rs b/src/store/tests/store.rs
index c383cf676..30bee2ee2 100644
--- a/src/store/tests/store.rs
+++ b/src/store/tests/store.rs
@@ -18,6 +18,7 @@ use crate::watchtower::*;
 use ckb_hash::new_blake2b;
 use ckb_types::packed::*;
 use ckb_types::prelude::*;
+use ckb_types::H256;
 use core::cmp::Ordering;
 use musig2::secp::MaybeScalar;
 use musig2::CompactSignature;
@@ -331,7 +332,7 @@ fn test_channel_actor_state_store() {
         local_pubkey: gen_rand_fiber_public_key(),
         remote_pubkey: gen_rand_fiber_public_key(),
         funding_tx: Some(Transaction::default()),
-        funding_tx_confirmed_at: Some((1.into(), 1)),
+        funding_tx_confirmed_at: Some((H256::default(), 1, 1)),
         is_acceptor: true,
         funding_udt_type_script: Some(Script::default()),
         to_local_amount: 100,