diff --git a/src/fiber/channel.rs b/src/fiber/channel.rs
index 6df4b61bb..8b52cfe90 100644
--- a/src/fiber/channel.rs
+++ b/src/fiber/channel.rs
@@ -67,7 +67,7 @@ use tentacle::secio::PeerId;
 use thiserror::Error;
 use tokio::sync::oneshot;
 
-use super::types::ForwardTlcResult;
+use super::{graph::ChannelUpdateInfo, types::ForwardTlcResult};
 use std::{
     collections::HashSet,
     fmt::{self, Debug},
@@ -76,6 +76,8 @@ use std::{
     u128,
 };
 
+use super::types::{ChannelUpdateChannelFlags, ChannelUpdateMessageFlags, UpdateTlcInfo};
+
 // - `empty_witness_args`: 16 bytes, fixed to 0x10000000100000001000000010000000, for compatibility with the xudt
 // - `pubkey`: 32 bytes, x only aggregated public key
 // - `signature`: 64 bytes, aggregated signature
@@ -93,17 +95,6 @@ pub const COMMITMENT_CELL_WITNESS_LEN: usize = 16 + 1 + 32 + 64;
 // is funded or not.
 pub const INITIAL_COMMITMENT_NUMBER: u64 = 0;
 
-// Whether we are receiving a channel update from node1 or node2.
-// If the flag is set, it means the channel update is from node1, otherwise it is from node2.
-pub const MESSAGE_OF_NODE1_FLAG: u32 = 0;
-
-// Whether we are receiving a channel update from node1 or node2.
-// If the flag is set, it means the channel update is from node2, otherwise it is from node1.
-pub const MESSAGE_OF_NODE2_FLAG: u32 = 1;
-
-// The channel is disabled, and no more tlcs can be added to the channel.
-pub const CHANNEL_DISABLED_FLAG: u32 = 1;
-
 const RETRYABLE_TLC_OPS_INTERVAL: Duration = Duration::from_millis(1000);
 
 #[derive(Debug)]
@@ -150,7 +141,22 @@ pub enum ChannelCommand {
     Update(UpdateCommand, RpcReplyPort<Result<(), String>>),
     ForwardTlcResult(ForwardTlcResult),
     #[cfg(test)]
-    ReloadState(),
+    ReloadState(ReloadParams),
+}
+
+#[cfg(test)]
+#[derive(Debug)]
+pub struct ReloadParams {
+    pub notify_changes: bool,
+}
+
+#[cfg(test)]
+impl Default for ReloadParams {
+    fn default() -> Self {
+        Self {
+            notify_changes: true,
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -223,6 +229,7 @@ pub struct TxUpdateCommand {
 pub struct OpenChannelParameter {
     pub funding_amount: u128,
     pub seed: [u8; 32],
+    pub tlc_info: ChannelTlcInfo,
     pub public_channel_info: Option<PublicChannelInfo>,
     pub funding_udt_type_script: Option<Script>,
     pub shutdown_script: Script,
@@ -237,6 +244,7 @@ pub struct OpenChannelParameter {
 pub struct AcceptChannelParameter {
     pub funding_amount: u128,
     pub reserved_ckb_amount: u64,
+    pub tlc_info: ChannelTlcInfo,
     pub public_channel_info: Option<PublicChannelInfo>,
     pub seed: [u8; 32],
     pub open_channel: OpenChannel,
@@ -324,7 +332,9 @@ where
         if state.reestablishing {
             match message {
                 FiberChannelMessage::ReestablishChannel(ref reestablish_channel) => {
-                    state.handle_reestablish_channel_message(reestablish_channel, &self.network)?;
+                    state
+                        .handle_reestablish_channel_message(reestablish_channel, &self.network)
+                        .await?;
                 }
                 _ => {
                     debug!("Ignoring message while reestablishing: {:?}", message);
@@ -482,6 +492,11 @@ where
                 state.maybe_channel_is_ready(&self.network).await;
                 Ok(())
             }
+            FiberChannelMessage::UpdateTlcInfo(update_tlc_info) => {
+                state.remote_tlc_info = Some(update_tlc_info.into());
+                state.update_graph_for_remote_channel_change(&self.network);
+                Ok(())
+            }
             FiberChannelMessage::AddTlc(add_tlc) => {
                 self.handle_add_tlc_peer_message(state, add_tlc)
             }
@@ -576,7 +591,9 @@ where
                 Ok(())
             }
             FiberChannelMessage::ReestablishChannel(ref reestablish_channel) => {
-                state.handle_reestablish_channel_message(reestablish_channel, &self.network)?;
+                state
+                    .handle_reestablish_channel_message(reestablish_channel, &self.network)
+                    .await?;
                 Ok(())
             }
             FiberChannelMessage::TxAbort(_)
@@ -697,6 +714,7 @@ where
         state: &mut ChannelActorState,
         inbound: bool,
     ) {
+        let previous_balance = state.get_local_balance();
         let pending_tlcs = if inbound {
             state.tlc_state.received_tlcs.tlcs.iter_mut()
         } else {
@@ -719,6 +737,10 @@ where
                 .await
                 .expect("expect remove tlc success");
         }
+        if state.get_local_balance() != previous_balance {
+            state.update_graph_for_local_channel_change(&self.network);
+            state.update_graph_for_remote_channel_change(&self.network);
+        }
     }
 
     async fn process_add_tlc_error(
@@ -990,49 +1012,45 @@ where
                 return Err(ProcessingChannelError::FinalIncorrectPaymentHash);
             }
         } else {
-            match state.public_channel_info.as_ref() {
-                Some(public_channel_info) if public_channel_info.enabled => {
-                    let min_tlc_value = public_channel_info.tlc_min_value;
-                    if min_tlc_value > received_amount {
-                        return Err(ProcessingChannelError::TlcAmountIsTooLow);
-                    }
+            if state.is_public() && state.is_tlc_forwarding_enabled() {
+                if state.local_tlc_info.tlc_minimum_value > received_amount {
+                    return Err(ProcessingChannelError::TlcAmountIsTooLow);
+                }
 
-                    if add_tlc.expiry
-                        < peeled_onion_packet.current.expiry + public_channel_info.tlc_expiry_delta
-                    {
-                        return Err(ProcessingChannelError::IncorrectTlcExpiry);
-                    }
+                if add_tlc.expiry
+                    < peeled_onion_packet.current.expiry + state.local_tlc_info.tlc_expiry_delta
+                {
+                    return Err(ProcessingChannelError::IncorrectTlcExpiry);
+                }
 
-                    assert!(received_amount >= forward_amount);
-                    let forward_fee = received_amount.saturating_sub(forward_amount);
-                    let fee_rate: u128 = public_channel_info.tlc_fee_proportional_millionths;
+                assert!(received_amount >= forward_amount);
+                let forward_fee = received_amount.saturating_sub(forward_amount);
+                let fee_rate: u128 = state.local_tlc_info.tlc_fee_proportional_millionths;
 
-                    let expected_fee = calculate_tlc_forward_fee(forward_amount, fee_rate);
-                    if expected_fee.is_err() || forward_fee < expected_fee.clone().unwrap() {
-                        error!(
-                            "too low forward_fee: {}, expected_fee: {:?}",
-                            forward_fee, expected_fee
-                        );
-                        return Err(ProcessingChannelError::TlcForwardFeeIsTooLow);
-                    }
-                    // if this is not the last hop, forward TLC to next hop
-                    self.register_retryable_forward_tlc(
-                        myself,
-                        state,
-                        add_tlc.tlc_id,
-                        add_tlc.payment_hash,
-                        peeled_onion_packet.clone(),
-                    )
-                    .await;
-                }
-                _ => {
-                    // if we don't have public channel info, we can not forward the TLC
-                    // this may happended some malicious sender build a invalid onion router
-                    return Err(ProcessingChannelError::InvalidState(
-                        "Received AddTlc message, but the channel is not public or disabled"
-                            .to_string(),
-                    ));
+                let expected_fee = calculate_tlc_forward_fee(forward_amount, fee_rate);
+                if expected_fee.is_err() || forward_fee < expected_fee.clone().unwrap() {
+                    error!(
+                        "too low forward_fee: {}, expected_fee: {:?}",
+                        forward_fee, expected_fee
+                    );
+                    return Err(ProcessingChannelError::TlcForwardFeeIsTooLow);
                 }
+                // if this is not the last hop, forward TLC to next hop
+                self.register_retryable_forward_tlc(
+                    myself,
+                    state,
+                    add_tlc.tlc_id,
+                    add_tlc.payment_hash,
+                    peeled_onion_packet.clone(),
+                )
+                .await;
+            } else {
+                // if we don't have public channel info, we can not forward the TLC
+                // this may happended some malicious sender build a invalid onion router
+                return Err(ProcessingChannelError::InvalidState(
+                    "Received AddTlc message, but the channel is not public or disabled"
+                        .to_string(),
+                ));
             }
         }
         Ok(())
@@ -1413,7 +1431,7 @@ where
 
         if updated {
             state
-                .generate_and_broadcast_channel_update(&self.network)
+                .notify_owned_channel_updated(&self.network, true)
                 .await;
         }
 
@@ -1827,11 +1845,17 @@ where
                 Ok(())
             }
             #[cfg(test)]
-            ChannelCommand::ReloadState() => {
+            ChannelCommand::ReloadState(reload_params) => {
                 *state = self
                     .store
                     .get_channel_actor_state(&state.get_id())
                     .expect("load channel state failed");
+                let ReloadParams { notify_changes } = reload_params;
+                if notify_changes {
+                    state
+                        .notify_owned_channel_updated(&self.network, false)
+                        .await;
+                }
                 Ok(())
             }
         }
@@ -1956,6 +1980,7 @@ where
                 funding_amount: local_funding_amount,
                 reserved_ckb_amount: local_reserved_ckb_amount,
                 shutdown_script: local_shutdown_script,
+                tlc_info,
                 public_channel_info,
                 seed,
                 open_channel,
@@ -2031,6 +2056,7 @@ where
                     *remote_max_tlc_number_in_flight,
                     max_tlc_number_in_flight,
                     max_tlc_value_in_flight,
+                    tlc_info,
                 );
                 state.check_accept_channel_parameters()?;
 
@@ -2082,6 +2108,7 @@ where
             ChannelInitializationParameter::OpenChannel(OpenChannelParameter {
                 funding_amount,
                 seed,
+                tlc_info,
                 public_channel_info,
                 funding_udt_type_script,
                 shutdown_script,
@@ -2126,6 +2153,7 @@ where
                     shutdown_script.clone(),
                     max_tlc_value_in_flight,
                     max_tlc_number_in_flight,
+                    tlc_info,
                 );
 
                 channel.check_open_channel_parameters()?;
@@ -2292,6 +2320,23 @@ where
 
         Ok(())
     }
+
+    async fn post_stop(
+        &self,
+        _myself: ActorRef<Self::Msg>,
+        state: &mut Self::State,
+    ) -> Result<(), ActorProcessingErr> {
+        if let Some(outpoint) = state.get_funding_transaction_outpoint() {
+            self.network
+                .send_message(NetworkActorMessage::new_event(
+                    NetworkActorEvent::OwnedChannelUpdateEvent(
+                        super::graph::OwnedChannelUpdateEvent::Down(outpoint),
+                    ),
+                ))
+                .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+        }
+        Ok(())
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -2932,6 +2977,9 @@ pub struct ChannelActorState {
     // The data below are only relevant if the channel is public.
     pub public_channel_info: Option<PublicChannelInfo>,
 
+    pub local_tlc_info: ChannelTlcInfo,
+    pub remote_tlc_info: Option<ChannelTlcInfo>,
+
     // The local public key used to establish p2p network connection.
     pub local_pubkey: Pubkey,
     // The remote public key used to establish p2p network connection.
@@ -3068,16 +3116,17 @@ pub struct ShutdownInfo {
     pub signature: Option<PartialSignature>,
 }
 
-// This struct holds the channel information that are only relevant when the channel
-// is public. The information includes signatures to the channel announcement message,
-// our config for the channel that will be published to the network (via ChannelUpdate).
-// For ChannelUpdate config, only information on our side are saved here because we have no
-// control to the config on the counterparty side. And they will publish
-// the config to the network via another ChannelUpdate message.
+// This struct holds the TLC information for the channel participants.
+// We can update this information through the channel update message.
 #[serde_as]
-#[derive(Default, Clone, Debug, Serialize, Deserialize)]
-pub struct PublicChannelInfo {
+#[derive(Default, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+pub struct ChannelTlcInfo {
+    // The timestamp when the following information is updated.
+    pub timestamp: u64,
+
+    // Whether this channel is enabled for TLC forwarding or not.
     pub enabled: bool,
+
     // The fee rate for tlc transfers. We only have these values set when
     // this is a public channel. Both sides may set this value differently.
     // This is a fee that is paid by the sender of the tlc.
@@ -3089,35 +3138,55 @@ pub struct PublicChannelInfo {
     pub tlc_expiry_delta: u64,
 
     /// The minimal tcl value we can receive in relay tlc
-    pub tlc_min_value: u128,
-
-    // Channel announcement signatures, may be empty for private channel.
-    pub local_channel_announcement_signature: Option<(EcdsaSignature, PartialSignature)>,
-    pub remote_channel_announcement_signature: Option<(EcdsaSignature, PartialSignature)>,
-
-    #[serde_as(as = "Option<PubNonceAsBytes>")]
-    pub remote_channel_announcement_nonce: Option<PubNonce>,
+    pub tlc_minimum_value: u128,
 
-    pub channel_announcement: Option<ChannelAnnouncement>,
-    pub channel_update: Option<ChannelUpdate>,
+    /// The maximal tcl value we can receive in relay tlc
+    pub tlc_maximum_value: u128,
 }
 
-impl PublicChannelInfo {
+impl ChannelTlcInfo {
     pub fn new(
         tlc_min_value: u128,
         tlc_expiry_delta: u64,
         tlc_fee_proportional_millionths: u128,
     ) -> Self {
         Self {
-            tlc_min_value,
+            tlc_minimum_value: tlc_min_value,
             tlc_expiry_delta,
             tlc_fee_proportional_millionths,
             enabled: true,
+            timestamp: now_timestamp_as_millis_u64(),
             ..Default::default()
         }
     }
 }
 
+// This struct holds the channel information that are only relevant when the channel
+// is public. The information includes signatures to the channel announcement message,
+// our config for the channel that will be published to the network (via ChannelUpdate).
+// For ChannelUpdate config, only information on our side are saved here because we have no
+// control to the config on the counterparty side. And they will publish
+// the config to the network via another ChannelUpdate message.
+#[serde_as]
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct PublicChannelInfo {
+    // Channel announcement signatures, may be empty for private channel.
+    pub local_channel_announcement_signature: Option<(EcdsaSignature, PartialSignature)>,
+    pub remote_channel_announcement_signature: Option<(EcdsaSignature, PartialSignature)>,
+
+    #[serde_as(as = "Option<PubNonceAsBytes>")]
+    pub remote_channel_announcement_nonce: Option<PubNonce>,
+
+    pub channel_announcement: Option<ChannelAnnouncement>,
+    pub channel_update: Option<ChannelUpdate>,
+}
+
+impl PublicChannelInfo {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct ClosedChannel {}
 
@@ -3420,6 +3489,14 @@ impl ChannelActorState {
         self.public_channel_info.is_some()
     }
 
+    pub fn is_ready(&self) -> bool {
+        matches!(self.state, ChannelState::ChannelReady())
+    }
+
+    pub fn is_tlc_forwarding_enabled(&self) -> bool {
+        self.local_tlc_info.enabled
+    }
+
     pub async fn try_create_channel_messages(
         &mut self,
         network: &ActorRef<NetworkActorMessage>,
@@ -3548,26 +3625,115 @@ impl ChannelActorState {
         self.do_generate_channel_update(network, |_update| {}).await
     }
 
+    fn create_update_tlc_info_message(&mut self) -> UpdateTlcInfo {
+        self.local_tlc_info.timestamp = now_timestamp_as_millis_u64();
+        UpdateTlcInfo {
+            channel_id: self.get_id(),
+            timestamp: self.local_tlc_info.timestamp,
+            channel_flags: self.get_channel_update_channel_flags(),
+            tlc_minimum_value: self.local_tlc_info.tlc_minimum_value,
+            tlc_maximum_value: self.local_tlc_info.tlc_maximum_value,
+            tlc_fee_proportional_millionths: self.local_tlc_info.tlc_fee_proportional_millionths,
+            tlc_expiry_delta: self.local_tlc_info.tlc_expiry_delta,
+        }
+    }
+
     async fn generate_disabled_channel_update(
         &mut self,
         network: &ActorRef<NetworkActorMessage>,
     ) -> ChannelUpdate {
         self.do_generate_channel_update(network, |update| {
-            update.channel_flags = CHANNEL_DISABLED_FLAG
+            update.channel_flags |= ChannelUpdateChannelFlags::DISABLED;
         })
         .await
     }
 
-    async fn generate_and_broadcast_channel_update(
+    // Notify the network, network graph and channel counterparty about the channel update.
+    // We do this on channel ready, channel reestablishment, user channel parameters update.
+    // Some of the events require us to send an OwnedChannelUpdateEvent::Up to the network actor,
+    // (e.g. channel ready and channel reestablishment) and some require us to send a
+    // OwnedChannelUpdateEvent::Updated (e.g. user channel parameters update) to the network actor.
+    // update_only is used to distinguish between the two cases.
+    async fn notify_owned_channel_updated(
         &mut self,
         network: &ActorRef<NetworkActorMessage>,
+        update_only: bool,
     ) {
-        let channel_update = self.generate_channel_update(network).await;
+        if update_only {
+            self.update_graph_for_local_channel_change(network);
+        } else {
+            self.update_graph_for_local_channel_ready(network);
+        }
+        if self.is_public() {
+            let channel_update = self.generate_channel_update(network).await;
+            network
+                .send_message(NetworkActorMessage::new_command(
+                    NetworkActorCommand::BroadcastMessages(vec![
+                        BroadcastMessageWithTimestamp::ChannelUpdate(channel_update),
+                    ]),
+                ))
+                .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+        }
+        self.send_update_tlc_info_message(network);
+    }
+
+    fn update_graph_for_remote_channel_change(&mut self, network: &ActorRef<NetworkActorMessage>) {
+        if let Some(channel_update_info) = self.get_remote_channel_update_info() {
+            let channel_outpoint = self.must_get_funding_transaction_outpoint();
+            let peer_id = self.get_remote_pubkey();
+            network
+                .send_message(NetworkActorMessage::new_event(
+                    NetworkActorEvent::OwnedChannelUpdateEvent(
+                        super::graph::OwnedChannelUpdateEvent::Updated(
+                            channel_outpoint,
+                            peer_id,
+                            channel_update_info,
+                        ),
+                    ),
+                ))
+                .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+        }
+    }
+
+    fn update_graph_for_local_channel_ready(&mut self, network: &ActorRef<NetworkActorMessage>) {
+        if let Ok(channel_info) = (&*self).try_into() {
+            network
+                .send_message(NetworkActorMessage::new_event(
+                    NetworkActorEvent::OwnedChannelUpdateEvent(
+                        super::graph::OwnedChannelUpdateEvent::Up(channel_info),
+                    ),
+                ))
+                .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+        }
+    }
+
+    fn update_graph_for_local_channel_change(&mut self, network: &ActorRef<NetworkActorMessage>) {
+        let channel_outpoint = self.must_get_funding_transaction_outpoint();
+        let peer_id = self.get_local_pubkey();
+        let channel_update_info = self.get_local_channel_update_info();
+        network
+            .send_message(NetworkActorMessage::new_event(
+                NetworkActorEvent::OwnedChannelUpdateEvent(
+                    super::graph::OwnedChannelUpdateEvent::Updated(
+                        channel_outpoint,
+                        peer_id,
+                        channel_update_info,
+                    ),
+                ),
+            ))
+            .expect(ASSUME_NETWORK_ACTOR_ALIVE);
+    }
+
+    fn send_update_tlc_info_message(&mut self, network: &ActorRef<NetworkActorMessage>) {
+        let update_tlc_info = self.create_update_tlc_info_message();
         network
             .send_message(NetworkActorMessage::new_command(
-                NetworkActorCommand::BroadcastMessages(vec![
-                    BroadcastMessageWithTimestamp::ChannelUpdate(channel_update),
-                ]),
+                NetworkActorCommand::SendFiberMessage(FiberMessageWithPeerId {
+                    peer_id: self.get_remote_peer_id(),
+                    message: FiberMessage::ChannelNormalOperation(
+                        FiberChannelMessage::UpdateTlcInfo(update_tlc_info),
+                    ),
+                }),
             ))
             .expect(ASSUME_NETWORK_ACTOR_ALIVE);
     }
@@ -3593,21 +3759,30 @@ impl ChannelActorState {
         Some(self.generate_channel_update(network).await)
     }
 
+    fn get_channel_update_channel_flags(&self) -> ChannelUpdateChannelFlags {
+        if self.is_tlc_forwarding_enabled() {
+            ChannelUpdateChannelFlags::empty()
+        } else {
+            ChannelUpdateChannelFlags::DISABLED
+        }
+    }
+
     pub fn get_unsigned_channel_update_message(&self) -> Option<ChannelUpdate> {
-        let local_is_node1 = self.local_is_node1();
-        let message_flags = if local_is_node1 { 0 } else { 1 };
-
-        self.public_channel_info.as_ref().and_then(|info| {
-            Some(ChannelUpdate::new_unsigned(
-                self.must_get_funding_transaction_outpoint(),
-                now_timestamp_as_millis_u64(),
-                message_flags,
-                0,
-                info.tlc_expiry_delta,
-                info.tlc_min_value,
-                info.tlc_fee_proportional_millionths,
-            ))
-        })
+        let message_flags = if self.local_is_node1() {
+            ChannelUpdateMessageFlags::UPDATE_OF_NODE1
+        } else {
+            ChannelUpdateMessageFlags::UPDATE_OF_NODE2
+        };
+
+        self.is_public().then_some(ChannelUpdate::new_unsigned(
+            self.must_get_funding_transaction_outpoint(),
+            now_timestamp_as_millis_u64(),
+            message_flags,
+            self.get_channel_update_channel_flags(),
+            self.local_tlc_info.tlc_expiry_delta,
+            self.local_tlc_info.tlc_minimum_value,
+            self.local_tlc_info.tlc_fee_proportional_millionths,
+        ))
     }
 
     pub fn new_inbound_channel<'a>(
@@ -3635,6 +3810,7 @@ impl ChannelActorState {
         remote_max_tlc_number_in_flight: u64,
         local_max_tlc_number_in_flight: u64,
         local_max_tlc_value_in_flight: u128,
+        local_tlc_info: ChannelTlcInfo,
     ) -> Self {
         let signer = InMemorySigner::generate_from_seed(seed);
         let local_base_pubkeys = signer.get_base_public_keys();
@@ -3652,6 +3828,8 @@ impl ChannelActorState {
         let mut state = Self {
             state: ChannelState::NegotiatingFunding(NegotiatingFundingFlags::THEIR_INIT_SENT),
             public_channel_info,
+            local_tlc_info,
+            remote_tlc_info: None,
             local_pubkey,
             remote_pubkey,
             funding_tx: None,
@@ -3715,6 +3893,7 @@ impl ChannelActorState {
         shutdown_script: Script,
         local_max_tlc_value_in_flight: u128,
         local_max_tlc_number_in_flight: u64,
+        local_tlc_info: ChannelTlcInfo,
     ) -> Self {
         let signer = InMemorySigner::generate_from_seed(seed);
         let local_pubkeys = signer.get_base_public_keys();
@@ -3722,6 +3901,8 @@ impl ChannelActorState {
         Self {
             state: ChannelState::NegotiatingFunding(NegotiatingFundingFlags::empty()),
             public_channel_info,
+            local_tlc_info,
+            remote_tlc_info: None,
             local_pubkey,
             remote_pubkey,
             funding_tx: None,
@@ -3944,7 +4125,7 @@ impl ChannelActorState {
         self.state = new_state;
     }
 
-    fn local_is_node1(&self) -> bool {
+    pub(crate) fn local_is_node1(&self) -> bool {
         self.local_pubkey < self.remote_pubkey
     }
 
@@ -4039,71 +4220,36 @@ impl ChannelActorState {
             .remote_channel_announcement_signature = Some((ecdsa_signature, partial_signatures));
     }
 
-    fn get_our_tlc_fee_proportional_millionths(&self) -> Option<u128> {
-        self.public_channel_info
-            .as_ref()
-            .map(|state| state.tlc_fee_proportional_millionths)
-    }
-
     fn update_our_tlc_fee_proportional_millionths(&mut self, fee: u128) -> bool {
-        let old_fee = self.get_our_tlc_fee_proportional_millionths();
-        match old_fee {
-            Some(old_fee) if old_fee == fee => false,
-            _ => {
-                self.public_channel_state_mut()
-                    .tlc_fee_proportional_millionths = fee;
-                true
-            }
+        if self.local_tlc_info.tlc_fee_proportional_millionths == fee {
+            return false;
         }
-    }
-
-    fn get_our_tlc_min_value(&self) -> Option<u128> {
-        self.public_channel_info
-            .as_ref()
-            .map(|state| state.tlc_min_value)
+        self.local_tlc_info.tlc_fee_proportional_millionths = fee;
+        true
     }
 
     fn update_our_tlc_min_value(&mut self, value: u128) -> bool {
-        let old_value = self.get_our_tlc_min_value();
-        match old_value {
-            Some(old_value) if old_value == value => false,
-            _ => {
-                self.public_channel_state_mut().tlc_min_value = value;
-                true
-            }
+        if self.local_tlc_info.tlc_minimum_value == value {
+            return false;
         }
-    }
-
-    fn get_our_enabled(&self) -> Option<bool> {
-        self.public_channel_info.as_ref().map(|state| state.enabled)
+        self.local_tlc_info.tlc_minimum_value = value;
+        true
     }
 
     fn update_our_enabled(&mut self, enabled: bool) -> bool {
-        let old_value = self.get_our_enabled();
-        match old_value {
-            Some(old_value) if old_value == enabled => false,
-            _ => {
-                self.public_channel_state_mut().enabled = enabled;
-                true
-            }
+        if self.local_tlc_info.enabled == enabled {
+            return false;
         }
-    }
-
-    fn get_our_tlc_expiry_delta(&self) -> Option<u64> {
-        self.public_channel_info
-            .as_ref()
-            .map(|info| info.tlc_expiry_delta)
+        self.local_tlc_info.enabled = enabled;
+        true
     }
 
     fn update_our_tlc_expiry_delta(&mut self, value: u64) -> bool {
-        let old_value = self.get_our_tlc_expiry_delta();
-        match old_value {
-            Some(old_value) if old_value == value => false,
-            _ => {
-                self.public_channel_state_mut().tlc_expiry_delta = value;
-                true
-            }
+        if self.local_tlc_info.tlc_expiry_delta == value {
+            return false;
         }
+        self.local_tlc_info.tlc_expiry_delta = value;
+        true
     }
 
     fn get_total_reserved_ckb_amount(&self) -> u64 {
@@ -4122,7 +4268,7 @@ impl ChannelActorState {
 
     // Get the total liquid capacity of the channel, which will exclude the reserved ckb amount.
     // This is the capacity used for gossiping channel information.
-    fn get_liquid_capacity(&self) -> u128 {
+    pub(crate) fn get_liquid_capacity(&self) -> u128 {
         let capacity = if self.funding_udt_type_script.is_some() {
             self.get_total_udt_amount()
         } else {
@@ -4238,14 +4384,38 @@ impl ChannelActorState {
         self.id
     }
 
+    pub fn get_local_pubkey(&self) -> Pubkey {
+        self.local_pubkey
+    }
+
     pub fn get_local_peer_id(&self) -> PeerId {
         self.local_pubkey.tentacle_peer_id()
     }
 
+    pub fn get_local_channel_update_info(&self) -> ChannelUpdateInfo {
+        let balance = self.get_remote_balance();
+        let mut info = ChannelUpdateInfo::from(&self.local_tlc_info);
+        info.inbound_liquidity = Some(balance);
+        info
+    }
+
+    pub fn get_remote_pubkey(&self) -> Pubkey {
+        self.remote_pubkey
+    }
+
     pub fn get_remote_peer_id(&self) -> PeerId {
         self.remote_pubkey.tentacle_peer_id()
     }
 
+    pub fn get_remote_channel_update_info(&self) -> Option<ChannelUpdateInfo> {
+        let balance = self.get_local_balance();
+        self.remote_tlc_info.as_ref().map(|tlc_info| {
+            let mut info = ChannelUpdateInfo::from(tlc_info);
+            info.inbound_liquidity = Some(balance);
+            info
+        })
+    }
+
     pub fn get_next_local_secnonce(&self) -> SecNonce {
         self.signer
             .derive_musig2_nonce(self.get_next_commitment_number(true))
@@ -5541,6 +5711,7 @@ impl ChannelActorState {
         self.increment_local_commitment_number();
         self.increment_remote_commitment_number();
         let peer_id = self.get_remote_peer_id();
+        self.notify_owned_channel_updated(network, false).await;
         network
             .send_message(NetworkActorMessage::new_event(
                 NetworkActorEvent::ChannelReady(
@@ -5696,7 +5867,7 @@ impl ChannelActorState {
         Ok(need_commitment_signed)
     }
 
-    fn handle_reestablish_channel_message(
+    async fn handle_reestablish_channel_message(
         &mut self,
         reestablish_channel: &ReestablishChannel,
         network: &ActorRef<NetworkActorMessage>,
@@ -5836,6 +6007,8 @@ impl ChannelActorState {
                     );
                 }
 
+                self.notify_owned_channel_updated(network, false).await;
+
                 debug_event!(network, "Reestablished channel in ChannelReady");
             }
             _ => {
diff --git a/src/fiber/gen/fiber.rs b/src/fiber/gen/fiber.rs
index 16edafea5..3a703f58b 100644
--- a/src/fiber/gen/fiber.rs
+++ b/src/fiber/gen/fiber.rs
@@ -7296,6 +7296,260 @@ impl molecule::prelude::Builder for ClosingSignedBuilder {
     }
 }
 #[derive(Clone)]
+pub struct UpdateTlcInfo(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for UpdateTlcInfo {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for UpdateTlcInfo {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for UpdateTlcInfo {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "channel_id", self.channel_id())?;
+        write!(f, ", {}: {}", "timestamp", self.timestamp())?;
+        write!(f, ", {}: {}", "channel_flags", self.channel_flags())?;
+        write!(f, ", {}: {}", "tlc_expiry_delta", self.tlc_expiry_delta())?;
+        write!(f, ", {}: {}", "tlc_minimum_value", self.tlc_minimum_value())?;
+        write!(f, ", {}: {}", "tlc_maximum_value", self.tlc_maximum_value())?;
+        write!(
+            f,
+            ", {}: {}",
+            "tlc_fee_proportional_millionths",
+            self.tlc_fee_proportional_millionths()
+        )?;
+        write!(f, " }}")
+    }
+}
+impl ::core::default::Default for UpdateTlcInfo {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        UpdateTlcInfo::new_unchecked(v)
+    }
+}
+impl UpdateTlcInfo {
+    const DEFAULT_VALUE: [u8; 100] = [
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ];
+    pub const TOTAL_SIZE: usize = 100;
+    pub const FIELD_SIZES: [usize; 7] = [32, 8, 4, 8, 16, 16, 16];
+    pub const FIELD_COUNT: usize = 7;
+    pub fn channel_id(&self) -> Byte32 {
+        Byte32::new_unchecked(self.0.slice(0..32))
+    }
+    pub fn timestamp(&self) -> Uint64 {
+        Uint64::new_unchecked(self.0.slice(32..40))
+    }
+    pub fn channel_flags(&self) -> Uint32 {
+        Uint32::new_unchecked(self.0.slice(40..44))
+    }
+    pub fn tlc_expiry_delta(&self) -> Uint64 {
+        Uint64::new_unchecked(self.0.slice(44..52))
+    }
+    pub fn tlc_minimum_value(&self) -> Uint128 {
+        Uint128::new_unchecked(self.0.slice(52..68))
+    }
+    pub fn tlc_maximum_value(&self) -> Uint128 {
+        Uint128::new_unchecked(self.0.slice(68..84))
+    }
+    pub fn tlc_fee_proportional_millionths(&self) -> Uint128 {
+        Uint128::new_unchecked(self.0.slice(84..100))
+    }
+    pub fn as_reader<'r>(&'r self) -> UpdateTlcInfoReader<'r> {
+        UpdateTlcInfoReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for UpdateTlcInfo {
+    type Builder = UpdateTlcInfoBuilder;
+    const NAME: &'static str = "UpdateTlcInfo";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        UpdateTlcInfo(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        UpdateTlcInfoReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        UpdateTlcInfoReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder()
+            .channel_id(self.channel_id())
+            .timestamp(self.timestamp())
+            .channel_flags(self.channel_flags())
+            .tlc_expiry_delta(self.tlc_expiry_delta())
+            .tlc_minimum_value(self.tlc_minimum_value())
+            .tlc_maximum_value(self.tlc_maximum_value())
+            .tlc_fee_proportional_millionths(self.tlc_fee_proportional_millionths())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct UpdateTlcInfoReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for UpdateTlcInfoReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for UpdateTlcInfoReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for UpdateTlcInfoReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "channel_id", self.channel_id())?;
+        write!(f, ", {}: {}", "timestamp", self.timestamp())?;
+        write!(f, ", {}: {}", "channel_flags", self.channel_flags())?;
+        write!(f, ", {}: {}", "tlc_expiry_delta", self.tlc_expiry_delta())?;
+        write!(f, ", {}: {}", "tlc_minimum_value", self.tlc_minimum_value())?;
+        write!(f, ", {}: {}", "tlc_maximum_value", self.tlc_maximum_value())?;
+        write!(
+            f,
+            ", {}: {}",
+            "tlc_fee_proportional_millionths",
+            self.tlc_fee_proportional_millionths()
+        )?;
+        write!(f, " }}")
+    }
+}
+impl<'r> UpdateTlcInfoReader<'r> {
+    pub const TOTAL_SIZE: usize = 100;
+    pub const FIELD_SIZES: [usize; 7] = [32, 8, 4, 8, 16, 16, 16];
+    pub const FIELD_COUNT: usize = 7;
+    pub fn channel_id(&self) -> Byte32Reader<'r> {
+        Byte32Reader::new_unchecked(&self.as_slice()[0..32])
+    }
+    pub fn timestamp(&self) -> Uint64Reader<'r> {
+        Uint64Reader::new_unchecked(&self.as_slice()[32..40])
+    }
+    pub fn channel_flags(&self) -> Uint32Reader<'r> {
+        Uint32Reader::new_unchecked(&self.as_slice()[40..44])
+    }
+    pub fn tlc_expiry_delta(&self) -> Uint64Reader<'r> {
+        Uint64Reader::new_unchecked(&self.as_slice()[44..52])
+    }
+    pub fn tlc_minimum_value(&self) -> Uint128Reader<'r> {
+        Uint128Reader::new_unchecked(&self.as_slice()[52..68])
+    }
+    pub fn tlc_maximum_value(&self) -> Uint128Reader<'r> {
+        Uint128Reader::new_unchecked(&self.as_slice()[68..84])
+    }
+    pub fn tlc_fee_proportional_millionths(&self) -> Uint128Reader<'r> {
+        Uint128Reader::new_unchecked(&self.as_slice()[84..100])
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for UpdateTlcInfoReader<'r> {
+    type Entity = UpdateTlcInfo;
+    const NAME: &'static str = "UpdateTlcInfoReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        UpdateTlcInfoReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], _compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len != Self::TOTAL_SIZE {
+            return ve!(Self, TotalSizeNotMatch, Self::TOTAL_SIZE, slice_len);
+        }
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct UpdateTlcInfoBuilder {
+    pub(crate) channel_id: Byte32,
+    pub(crate) timestamp: Uint64,
+    pub(crate) channel_flags: Uint32,
+    pub(crate) tlc_expiry_delta: Uint64,
+    pub(crate) tlc_minimum_value: Uint128,
+    pub(crate) tlc_maximum_value: Uint128,
+    pub(crate) tlc_fee_proportional_millionths: Uint128,
+}
+impl UpdateTlcInfoBuilder {
+    pub const TOTAL_SIZE: usize = 100;
+    pub const FIELD_SIZES: [usize; 7] = [32, 8, 4, 8, 16, 16, 16];
+    pub const FIELD_COUNT: usize = 7;
+    pub fn channel_id(mut self, v: Byte32) -> Self {
+        self.channel_id = v;
+        self
+    }
+    pub fn timestamp(mut self, v: Uint64) -> Self {
+        self.timestamp = v;
+        self
+    }
+    pub fn channel_flags(mut self, v: Uint32) -> Self {
+        self.channel_flags = v;
+        self
+    }
+    pub fn tlc_expiry_delta(mut self, v: Uint64) -> Self {
+        self.tlc_expiry_delta = v;
+        self
+    }
+    pub fn tlc_minimum_value(mut self, v: Uint128) -> Self {
+        self.tlc_minimum_value = v;
+        self
+    }
+    pub fn tlc_maximum_value(mut self, v: Uint128) -> Self {
+        self.tlc_maximum_value = v;
+        self
+    }
+    pub fn tlc_fee_proportional_millionths(mut self, v: Uint128) -> Self {
+        self.tlc_fee_proportional_millionths = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for UpdateTlcInfoBuilder {
+    type Entity = UpdateTlcInfo;
+    const NAME: &'static str = "UpdateTlcInfoBuilder";
+    fn expected_length(&self) -> usize {
+        Self::TOTAL_SIZE
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        writer.write_all(self.channel_id.as_slice())?;
+        writer.write_all(self.timestamp.as_slice())?;
+        writer.write_all(self.channel_flags.as_slice())?;
+        writer.write_all(self.tlc_expiry_delta.as_slice())?;
+        writer.write_all(self.tlc_minimum_value.as_slice())?;
+        writer.write_all(self.tlc_maximum_value.as_slice())?;
+        writer.write_all(self.tlc_fee_proportional_millionths.as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        UpdateTlcInfo::new_unchecked(inner.into())
+    }
+}
+#[derive(Clone)]
 pub struct AddTlc(molecule::bytes::Bytes);
 impl ::core::fmt::LowerHex for AddTlc {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
@@ -11163,7 +11417,7 @@ impl FiberMessage {
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ];
-    pub const ITEMS_COUNT: usize = 17;
+    pub const ITEMS_COUNT: usize = 18;
     pub fn item_id(&self) -> molecule::Number {
         molecule::unpack_number(self.as_slice())
     }
@@ -11180,13 +11434,14 @@ impl FiberMessage {
             7 => TxAckRBF::new_unchecked(inner).into(),
             8 => CommitmentSigned::new_unchecked(inner).into(),
             9 => ChannelReady::new_unchecked(inner).into(),
-            10 => AddTlc::new_unchecked(inner).into(),
-            11 => RemoveTlc::new_unchecked(inner).into(),
-            12 => RevokeAndAck::new_unchecked(inner).into(),
-            13 => Shutdown::new_unchecked(inner).into(),
-            14 => ClosingSigned::new_unchecked(inner).into(),
-            15 => ReestablishChannel::new_unchecked(inner).into(),
-            16 => AnnouncementSignatures::new_unchecked(inner).into(),
+            10 => UpdateTlcInfo::new_unchecked(inner).into(),
+            11 => AddTlc::new_unchecked(inner).into(),
+            12 => RemoveTlc::new_unchecked(inner).into(),
+            13 => RevokeAndAck::new_unchecked(inner).into(),
+            14 => Shutdown::new_unchecked(inner).into(),
+            15 => ClosingSigned::new_unchecked(inner).into(),
+            16 => ReestablishChannel::new_unchecked(inner).into(),
+            17 => AnnouncementSignatures::new_unchecked(inner).into(),
             _ => panic!("{}: invalid data", Self::NAME),
         }
     }
@@ -11243,7 +11498,7 @@ impl<'r> ::core::fmt::Display for FiberMessageReader<'r> {
     }
 }
 impl<'r> FiberMessageReader<'r> {
-    pub const ITEMS_COUNT: usize = 17;
+    pub const ITEMS_COUNT: usize = 18;
     pub fn item_id(&self) -> molecule::Number {
         molecule::unpack_number(self.as_slice())
     }
@@ -11260,13 +11515,14 @@ impl<'r> FiberMessageReader<'r> {
             7 => TxAckRBFReader::new_unchecked(inner).into(),
             8 => CommitmentSignedReader::new_unchecked(inner).into(),
             9 => ChannelReadyReader::new_unchecked(inner).into(),
-            10 => AddTlcReader::new_unchecked(inner).into(),
-            11 => RemoveTlcReader::new_unchecked(inner).into(),
-            12 => RevokeAndAckReader::new_unchecked(inner).into(),
-            13 => ShutdownReader::new_unchecked(inner).into(),
-            14 => ClosingSignedReader::new_unchecked(inner).into(),
-            15 => ReestablishChannelReader::new_unchecked(inner).into(),
-            16 => AnnouncementSignaturesReader::new_unchecked(inner).into(),
+            10 => UpdateTlcInfoReader::new_unchecked(inner).into(),
+            11 => AddTlcReader::new_unchecked(inner).into(),
+            12 => RemoveTlcReader::new_unchecked(inner).into(),
+            13 => RevokeAndAckReader::new_unchecked(inner).into(),
+            14 => ShutdownReader::new_unchecked(inner).into(),
+            15 => ClosingSignedReader::new_unchecked(inner).into(),
+            16 => ReestablishChannelReader::new_unchecked(inner).into(),
+            17 => AnnouncementSignaturesReader::new_unchecked(inner).into(),
             _ => panic!("{}: invalid data", Self::NAME),
         }
     }
@@ -11302,13 +11558,14 @@ impl<'r> molecule::prelude::Reader<'r> for FiberMessageReader<'r> {
             7 => TxAckRBFReader::verify(inner_slice, compatible),
             8 => CommitmentSignedReader::verify(inner_slice, compatible),
             9 => ChannelReadyReader::verify(inner_slice, compatible),
-            10 => AddTlcReader::verify(inner_slice, compatible),
-            11 => RemoveTlcReader::verify(inner_slice, compatible),
-            12 => RevokeAndAckReader::verify(inner_slice, compatible),
-            13 => ShutdownReader::verify(inner_slice, compatible),
-            14 => ClosingSignedReader::verify(inner_slice, compatible),
-            15 => ReestablishChannelReader::verify(inner_slice, compatible),
-            16 => AnnouncementSignaturesReader::verify(inner_slice, compatible),
+            10 => UpdateTlcInfoReader::verify(inner_slice, compatible),
+            11 => AddTlcReader::verify(inner_slice, compatible),
+            12 => RemoveTlcReader::verify(inner_slice, compatible),
+            13 => RevokeAndAckReader::verify(inner_slice, compatible),
+            14 => ShutdownReader::verify(inner_slice, compatible),
+            15 => ClosingSignedReader::verify(inner_slice, compatible),
+            16 => ReestablishChannelReader::verify(inner_slice, compatible),
+            17 => AnnouncementSignaturesReader::verify(inner_slice, compatible),
             _ => ve!(Self, UnknownItem, Self::ITEMS_COUNT, item_id),
         }?;
         Ok(())
@@ -11317,7 +11574,7 @@ impl<'r> molecule::prelude::Reader<'r> for FiberMessageReader<'r> {
 #[derive(Clone, Debug, Default)]
 pub struct FiberMessageBuilder(pub(crate) FiberMessageUnion);
 impl FiberMessageBuilder {
-    pub const ITEMS_COUNT: usize = 17;
+    pub const ITEMS_COUNT: usize = 18;
     pub fn set<I>(mut self, v: I) -> Self
     where
         I: ::core::convert::Into<FiberMessageUnion>,
@@ -11355,6 +11612,7 @@ pub enum FiberMessageUnion {
     TxAckRBF(TxAckRBF),
     CommitmentSigned(CommitmentSigned),
     ChannelReady(ChannelReady),
+    UpdateTlcInfo(UpdateTlcInfo),
     AddTlc(AddTlc),
     RemoveTlc(RemoveTlc),
     RevokeAndAck(RevokeAndAck),
@@ -11375,6 +11633,7 @@ pub enum FiberMessageUnionReader<'r> {
     TxAckRBF(TxAckRBFReader<'r>),
     CommitmentSigned(CommitmentSignedReader<'r>),
     ChannelReady(ChannelReadyReader<'r>),
+    UpdateTlcInfo(UpdateTlcInfoReader<'r>),
     AddTlc(AddTlcReader<'r>),
     RemoveTlc(RemoveTlcReader<'r>),
     RevokeAndAck(RevokeAndAckReader<'r>),
@@ -11421,6 +11680,9 @@ impl ::core::fmt::Display for FiberMessageUnion {
             FiberMessageUnion::ChannelReady(ref item) => {
                 write!(f, "{}::{}({})", Self::NAME, ChannelReady::NAME, item)
             }
+            FiberMessageUnion::UpdateTlcInfo(ref item) => {
+                write!(f, "{}::{}({})", Self::NAME, UpdateTlcInfo::NAME, item)
+            }
             FiberMessageUnion::AddTlc(ref item) => {
                 write!(f, "{}::{}({})", Self::NAME, AddTlc::NAME, item)
             }
@@ -11484,6 +11746,9 @@ impl<'r> ::core::fmt::Display for FiberMessageUnionReader<'r> {
             FiberMessageUnionReader::ChannelReady(ref item) => {
                 write!(f, "{}::{}({})", Self::NAME, ChannelReady::NAME, item)
             }
+            FiberMessageUnionReader::UpdateTlcInfo(ref item) => {
+                write!(f, "{}::{}({})", Self::NAME, UpdateTlcInfo::NAME, item)
+            }
             FiberMessageUnionReader::AddTlc(ref item) => {
                 write!(f, "{}::{}({})", Self::NAME, AddTlc::NAME, item)
             }
@@ -11527,6 +11792,7 @@ impl FiberMessageUnion {
             FiberMessageUnion::TxAckRBF(ref item) => write!(f, "{}", item),
             FiberMessageUnion::CommitmentSigned(ref item) => write!(f, "{}", item),
             FiberMessageUnion::ChannelReady(ref item) => write!(f, "{}", item),
+            FiberMessageUnion::UpdateTlcInfo(ref item) => write!(f, "{}", item),
             FiberMessageUnion::AddTlc(ref item) => write!(f, "{}", item),
             FiberMessageUnion::RemoveTlc(ref item) => write!(f, "{}", item),
             FiberMessageUnion::RevokeAndAck(ref item) => write!(f, "{}", item),
@@ -11550,6 +11816,7 @@ impl<'r> FiberMessageUnionReader<'r> {
             FiberMessageUnionReader::TxAckRBF(ref item) => write!(f, "{}", item),
             FiberMessageUnionReader::CommitmentSigned(ref item) => write!(f, "{}", item),
             FiberMessageUnionReader::ChannelReady(ref item) => write!(f, "{}", item),
+            FiberMessageUnionReader::UpdateTlcInfo(ref item) => write!(f, "{}", item),
             FiberMessageUnionReader::AddTlc(ref item) => write!(f, "{}", item),
             FiberMessageUnionReader::RemoveTlc(ref item) => write!(f, "{}", item),
             FiberMessageUnionReader::RevokeAndAck(ref item) => write!(f, "{}", item),
@@ -11610,6 +11877,11 @@ impl ::core::convert::From<ChannelReady> for FiberMessageUnion {
         FiberMessageUnion::ChannelReady(item)
     }
 }
+impl ::core::convert::From<UpdateTlcInfo> for FiberMessageUnion {
+    fn from(item: UpdateTlcInfo) -> Self {
+        FiberMessageUnion::UpdateTlcInfo(item)
+    }
+}
 impl ::core::convert::From<AddTlc> for FiberMessageUnion {
     fn from(item: AddTlc) -> Self {
         FiberMessageUnion::AddTlc(item)
@@ -11695,6 +11967,11 @@ impl<'r> ::core::convert::From<ChannelReadyReader<'r>> for FiberMessageUnionRead
         FiberMessageUnionReader::ChannelReady(item)
     }
 }
+impl<'r> ::core::convert::From<UpdateTlcInfoReader<'r>> for FiberMessageUnionReader<'r> {
+    fn from(item: UpdateTlcInfoReader<'r>) -> Self {
+        FiberMessageUnionReader::UpdateTlcInfo(item)
+    }
+}
 impl<'r> ::core::convert::From<AddTlcReader<'r>> for FiberMessageUnionReader<'r> {
     fn from(item: AddTlcReader<'r>) -> Self {
         FiberMessageUnionReader::AddTlc(item)
@@ -11744,6 +12021,7 @@ impl FiberMessageUnion {
             FiberMessageUnion::TxAckRBF(item) => item.as_bytes(),
             FiberMessageUnion::CommitmentSigned(item) => item.as_bytes(),
             FiberMessageUnion::ChannelReady(item) => item.as_bytes(),
+            FiberMessageUnion::UpdateTlcInfo(item) => item.as_bytes(),
             FiberMessageUnion::AddTlc(item) => item.as_bytes(),
             FiberMessageUnion::RemoveTlc(item) => item.as_bytes(),
             FiberMessageUnion::RevokeAndAck(item) => item.as_bytes(),
@@ -11765,6 +12043,7 @@ impl FiberMessageUnion {
             FiberMessageUnion::TxAckRBF(item) => item.as_slice(),
             FiberMessageUnion::CommitmentSigned(item) => item.as_slice(),
             FiberMessageUnion::ChannelReady(item) => item.as_slice(),
+            FiberMessageUnion::UpdateTlcInfo(item) => item.as_slice(),
             FiberMessageUnion::AddTlc(item) => item.as_slice(),
             FiberMessageUnion::RemoveTlc(item) => item.as_slice(),
             FiberMessageUnion::RevokeAndAck(item) => item.as_slice(),
@@ -11786,13 +12065,14 @@ impl FiberMessageUnion {
             FiberMessageUnion::TxAckRBF(_) => 7,
             FiberMessageUnion::CommitmentSigned(_) => 8,
             FiberMessageUnion::ChannelReady(_) => 9,
-            FiberMessageUnion::AddTlc(_) => 10,
-            FiberMessageUnion::RemoveTlc(_) => 11,
-            FiberMessageUnion::RevokeAndAck(_) => 12,
-            FiberMessageUnion::Shutdown(_) => 13,
-            FiberMessageUnion::ClosingSigned(_) => 14,
-            FiberMessageUnion::ReestablishChannel(_) => 15,
-            FiberMessageUnion::AnnouncementSignatures(_) => 16,
+            FiberMessageUnion::UpdateTlcInfo(_) => 10,
+            FiberMessageUnion::AddTlc(_) => 11,
+            FiberMessageUnion::RemoveTlc(_) => 12,
+            FiberMessageUnion::RevokeAndAck(_) => 13,
+            FiberMessageUnion::Shutdown(_) => 14,
+            FiberMessageUnion::ClosingSigned(_) => 15,
+            FiberMessageUnion::ReestablishChannel(_) => 16,
+            FiberMessageUnion::AnnouncementSignatures(_) => 17,
         }
     }
     pub fn item_name(&self) -> &str {
@@ -11807,6 +12087,7 @@ impl FiberMessageUnion {
             FiberMessageUnion::TxAckRBF(_) => "TxAckRBF",
             FiberMessageUnion::CommitmentSigned(_) => "CommitmentSigned",
             FiberMessageUnion::ChannelReady(_) => "ChannelReady",
+            FiberMessageUnion::UpdateTlcInfo(_) => "UpdateTlcInfo",
             FiberMessageUnion::AddTlc(_) => "AddTlc",
             FiberMessageUnion::RemoveTlc(_) => "RemoveTlc",
             FiberMessageUnion::RevokeAndAck(_) => "RevokeAndAck",
@@ -11828,6 +12109,7 @@ impl FiberMessageUnion {
             FiberMessageUnion::TxAckRBF(item) => item.as_reader().into(),
             FiberMessageUnion::CommitmentSigned(item) => item.as_reader().into(),
             FiberMessageUnion::ChannelReady(item) => item.as_reader().into(),
+            FiberMessageUnion::UpdateTlcInfo(item) => item.as_reader().into(),
             FiberMessageUnion::AddTlc(item) => item.as_reader().into(),
             FiberMessageUnion::RemoveTlc(item) => item.as_reader().into(),
             FiberMessageUnion::RevokeAndAck(item) => item.as_reader().into(),
@@ -11852,6 +12134,7 @@ impl<'r> FiberMessageUnionReader<'r> {
             FiberMessageUnionReader::TxAckRBF(item) => item.as_slice(),
             FiberMessageUnionReader::CommitmentSigned(item) => item.as_slice(),
             FiberMessageUnionReader::ChannelReady(item) => item.as_slice(),
+            FiberMessageUnionReader::UpdateTlcInfo(item) => item.as_slice(),
             FiberMessageUnionReader::AddTlc(item) => item.as_slice(),
             FiberMessageUnionReader::RemoveTlc(item) => item.as_slice(),
             FiberMessageUnionReader::RevokeAndAck(item) => item.as_slice(),
@@ -11873,13 +12156,14 @@ impl<'r> FiberMessageUnionReader<'r> {
             FiberMessageUnionReader::TxAckRBF(_) => 7,
             FiberMessageUnionReader::CommitmentSigned(_) => 8,
             FiberMessageUnionReader::ChannelReady(_) => 9,
-            FiberMessageUnionReader::AddTlc(_) => 10,
-            FiberMessageUnionReader::RemoveTlc(_) => 11,
-            FiberMessageUnionReader::RevokeAndAck(_) => 12,
-            FiberMessageUnionReader::Shutdown(_) => 13,
-            FiberMessageUnionReader::ClosingSigned(_) => 14,
-            FiberMessageUnionReader::ReestablishChannel(_) => 15,
-            FiberMessageUnionReader::AnnouncementSignatures(_) => 16,
+            FiberMessageUnionReader::UpdateTlcInfo(_) => 10,
+            FiberMessageUnionReader::AddTlc(_) => 11,
+            FiberMessageUnionReader::RemoveTlc(_) => 12,
+            FiberMessageUnionReader::RevokeAndAck(_) => 13,
+            FiberMessageUnionReader::Shutdown(_) => 14,
+            FiberMessageUnionReader::ClosingSigned(_) => 15,
+            FiberMessageUnionReader::ReestablishChannel(_) => 16,
+            FiberMessageUnionReader::AnnouncementSignatures(_) => 17,
         }
     }
     pub fn item_name(&self) -> &str {
@@ -11894,6 +12178,7 @@ impl<'r> FiberMessageUnionReader<'r> {
             FiberMessageUnionReader::TxAckRBF(_) => "TxAckRBF",
             FiberMessageUnionReader::CommitmentSigned(_) => "CommitmentSigned",
             FiberMessageUnionReader::ChannelReady(_) => "ChannelReady",
+            FiberMessageUnionReader::UpdateTlcInfo(_) => "UpdateTlcInfo",
             FiberMessageUnionReader::AddTlc(_) => "AddTlc",
             FiberMessageUnionReader::RemoveTlc(_) => "RemoveTlc",
             FiberMessageUnionReader::RevokeAndAck(_) => "RevokeAndAck",
@@ -11954,6 +12239,11 @@ impl From<ChannelReady> for FiberMessage {
         Self::new_builder().set(value).build()
     }
 }
+impl From<UpdateTlcInfo> for FiberMessage {
+    fn from(value: UpdateTlcInfo) -> Self {
+        Self::new_builder().set(value).build()
+    }
+}
 impl From<AddTlc> for FiberMessage {
     fn from(value: AddTlc) -> Self {
         Self::new_builder().set(value).build()
diff --git a/src/fiber/graph.rs b/src/fiber/graph.rs
index 80a21abae..a28eb1798 100644
--- a/src/fiber/graph.rs
+++ b/src/fiber/graph.rs
@@ -1,4 +1,4 @@
-use super::channel::ChannelActorStateStore;
+use super::channel::{ChannelActorState, ChannelActorStateStore, ChannelTlcInfo};
 use super::config::AnnouncedNodeName;
 use super::gossip::GossipMessageStore;
 use super::history::{Direction, InternalResult, PaymentHistory, TimedResult};
@@ -144,6 +144,59 @@ impl ChannelInfo {
             .map(|n| n.timestamp)
             .max(self.update_of_node1.as_ref().map(|n| n.timestamp))
     }
+
+    #[cfg(test)]
+    pub fn get_channel_update_of(&self, node: Pubkey) -> Option<&ChannelUpdateInfo> {
+        if self.node1() == node {
+            self.update_of_node1.as_ref()
+        } else if self.node2() == node {
+            self.update_of_node2.as_ref()
+        } else {
+            None
+        }
+    }
+}
+
+impl TryFrom<&ChannelActorState> for ChannelInfo {
+    type Error = String;
+
+    fn try_from(state: &ChannelActorState) -> Result<Self, Self::Error> {
+        if !state.is_ready() {
+            return Err("Channel is not ready".to_string());
+        }
+
+        let timestamp = state.must_get_funding_transaction_timestamp();
+        let channel_outpoint = state.must_get_funding_transaction_outpoint();
+        let capacity = state.get_liquid_capacity();
+        let udt_type_script = state.funding_udt_type_script.clone();
+
+        let (node1, node2, update_of_node1, update_of_node2) = if state.local_is_node1() {
+            (
+                state.local_pubkey,
+                state.remote_pubkey,
+                Some(state.get_local_channel_update_info()),
+                state.get_remote_channel_update_info(),
+            )
+        } else {
+            (
+                state.remote_pubkey,
+                state.local_pubkey,
+                state.get_remote_channel_update_info(),
+                Some(state.get_local_channel_update_info()),
+            )
+        };
+        Ok(Self {
+            channel_outpoint,
+            timestamp,
+            features: 0,
+            node1,
+            node2,
+            capacity,
+            udt_type_script,
+            update_of_node1,
+            update_of_node2,
+        })
+    }
 }
 
 impl From<(u64, ChannelAnnouncement)> for ChannelInfo {
@@ -168,6 +221,11 @@ pub struct ChannelUpdateInfo {
     pub timestamp: u64,
     /// Whether the channel can be currently used for payments (in this one direction).
     pub enabled: bool,
+    /// The exact amount of balance that we can receive from the other party via the channel.
+    /// Note that this is not our balance, but the balance of the other party.
+    /// This node is forwarding the balance for the other party, so we need to use the receivable balance
+    /// instead of our balance.
+    pub inbound_liquidity: Option<u128>,
     /// The difference in htlc expiry values that you must have when routing through this channel (in milliseconds).
     pub tlc_expiry_delta: u64,
     /// The minimum value, which must be relayed to the next hop via the channel
@@ -175,6 +233,25 @@ pub struct ChannelUpdateInfo {
     pub fee_rate: u64,
 }
 
+impl From<&ChannelTlcInfo> for ChannelUpdateInfo {
+    fn from(info: &ChannelTlcInfo) -> Self {
+        Self {
+            timestamp: info.timestamp,
+            enabled: info.enabled,
+            inbound_liquidity: None,
+            tlc_expiry_delta: info.tlc_expiry_delta,
+            tlc_minimum_value: info.tlc_minimum_value,
+            fee_rate: info.tlc_fee_proportional_millionths as u64,
+        }
+    }
+}
+
+impl From<ChannelTlcInfo> for ChannelUpdateInfo {
+    fn from(info: ChannelTlcInfo) -> Self {
+        Self::from(&info)
+    }
+}
+
 impl From<ChannelUpdate> for ChannelUpdateInfo {
     fn from(update: ChannelUpdate) -> Self {
         Self::from(&update)
@@ -186,6 +263,7 @@ impl From<&ChannelUpdate> for ChannelUpdateInfo {
         Self {
             timestamp: update.timestamp,
             enabled: !update.is_disabled(),
+            inbound_liquidity: None,
             tlc_expiry_delta: update.tlc_expiry_delta,
             tlc_minimum_value: update.tlc_minimum_value,
             fee_rate: update.tlc_fee_proportional_millionths as u64,
@@ -193,8 +271,29 @@ impl From<&ChannelUpdate> for ChannelUpdateInfo {
     }
 }
 
+/// Update for our own channel has been made. We can use those events to update our graph.
+/// The events only contain the information that is relevant for our own channels.
+/// Other channel update events should be processed by gossip messages.
+#[derive(Debug)]
+pub enum OwnedChannelUpdateEvent {
+    /// The channel is back online and can be used for routing payments.
+    /// This normally means the peer is now reachable.
+    Up(ChannelInfo),
+    /// The channel is down and should not be used for routing payments.
+    /// This normally means the peer is not reachable.
+    Down(OutPoint),
+    /// One direction of the channel is updated (e.g. new balance, new fee rate).
+    Updated(OutPoint, Pubkey, ChannelUpdateInfo),
+}
+
 #[derive(Clone, Debug)]
 pub struct NetworkGraph<S> {
+    // Whether to always process gossip messages for our own channels.
+    // See comments in should_process_gossip_message_for_channel for why we need this.
+    // TLDR: Most of the tests do not need this. Only tests in src/fiber/tests/graph.rs need this.
+    // We will only set this to true for tests in src/fiber/tests/graph.rs.
+    #[cfg(test)]
+    pub always_process_gossip_message: bool,
     // The pubkey of the node that is running this instance of the network graph.
     source: Pubkey,
     // All the channels in the network.
@@ -252,6 +351,8 @@ where
 {
     pub fn new(store: S, source: Pubkey, announce_private_addr: bool) -> Self {
         let mut network_graph = Self {
+            #[cfg(test)]
+            always_process_gossip_message: false,
             source,
             channels: HashMap::new(),
             nodes: HashMap::new(),
@@ -313,6 +414,31 @@ where
         return true;
     }
 
+    // Process the events that are relevant for our own channels, and update the graph accordingly.
+    pub(crate) fn process_owned_channel_update_event(&mut self, event: OwnedChannelUpdateEvent) {
+        match event {
+            OwnedChannelUpdateEvent::Up(channel_info) => {
+                // Normally the channel_info passed here is the latest channel info,
+                // so we can just overwrite the old channel info.
+                self.channels
+                    .insert(channel_info.channel_outpoint.clone(), channel_info);
+            }
+            OwnedChannelUpdateEvent::Down(channel_outpoint) => {
+                self.channels.remove(&channel_outpoint);
+            }
+            OwnedChannelUpdateEvent::Updated(channel_outpoint, node, channel_update) => {
+                if let Some(channel) = self.channels.get_mut(&channel_outpoint) {
+                    if node == channel.node2() {
+                        channel.update_of_node2 = Some(channel_update);
+                    }
+                    if node == channel.node1() {
+                        channel.update_of_node1 = Some(channel_update);
+                    }
+                }
+            }
+        }
+    }
+
     // Load all the broadcast messages starting from latest_cursor from the store.
     // Process them and set nodes and channels accordingly.
     pub(crate) fn load_from_store(&mut self) {
@@ -363,11 +489,33 @@ where
         self.channels.get_mut(channel_outpoint)
     }
 
+    // We don't need to process our own channel announcement with gossip messages.
+    // They are processed by passing OwnedChannelUpdateEvents to the graph.
+    // These are real-time events with more detailed information (e.g. balance).
+    // We don't want to overwrite their detailed information here.
+    // But tests in src/fiber/tests/graph.rs need to process gossip messages
+    // to update the network graph. Many of the tests are messages from the graph.source.
+    // If we ignore these messages, the graph won't be updated. And many tests will fail.
+    fn should_process_gossip_message_for_nodes(&self, node1: &Pubkey, node2: &Pubkey) -> bool {
+        #[cfg(test)]
+        if self.always_process_gossip_message {
+            return true;
+        }
+        !(&self.source == node1 || &self.source == node2)
+    }
+
     fn process_channel_announcement(
         &mut self,
         timestamp: u64,
         channel_announcement: ChannelAnnouncement,
     ) -> Option<Cursor> {
+        if !self.should_process_gossip_message_for_nodes(
+            &channel_announcement.node1_id,
+            &channel_announcement.node2_id,
+        ) {
+            return None;
+        }
+
         match self.channels.get(&channel_announcement.channel_outpoint) {
             Some(_channel) => {
                 trace!(
@@ -408,11 +556,16 @@ where
     }
 
     fn process_channel_update(&mut self, channel_update: ChannelUpdate) -> Option<Cursor> {
-        let channel_outpoint = &channel_update.channel_outpoint;
-        // The channel update message may have smaller timestamp than channel announcement.
-        // So it is possible that the channel announcement is not loaded into the graph yet,
-        // when we receive the channel update message.
-        let channel = self.load_channel_info_mut(channel_outpoint)?;
+        match self.get_channel(&channel_update.channel_outpoint) {
+            Some(channel)
+                if !self
+                    .should_process_gossip_message_for_nodes(&channel.node1, &channel.node2) =>
+            {
+                return None;
+            }
+            _ => {}
+        }
+        let channel = self.load_channel_info_mut(&channel_update.channel_outpoint)?;
         let update_info = if channel_update.is_update_of_node_1() {
             &mut channel.update_of_node1
         } else {
@@ -594,15 +747,28 @@ where
 
         // Iterating over HashMap's values is not guaranteed to be in order,
         // which may introduce randomness in the path finding.
-        // the weight algorithm in find_path does not considering capacity,
-        // so the channel with larger capacity maybe have the same weight with the channel with smaller capacity
-        // so we sort by capacity reverse order to make sure we try channel with larger capacity firstly
-        channels.sort_by(|(_, _, a, _), (_, _, b, _)| {
-            b.capacity().cmp(&a.capacity()).then(
-                b.channel_last_update_time()
-                    .cmp(&a.channel_last_update_time()),
-            )
-        });
+        // We will first sort the channels by inbound_liquidity, then capacity, and at last update time.
+        // This is because the weight algorithm in find_path does not considering inbound_liquidity and capacity,
+        // so the channel with larger inbound_liquidity/capacity maybe have the same weight with the channel
+        // with smaller inbound_liquidity/capacity, even though the former have better chance to success.
+        channels.sort_by(
+            |(_, _, a_channel_info, a_channel_update_info),
+             (_, _, b_channel_info, b_channel_update_info)| {
+                b_channel_update_info
+                    .inbound_liquidity
+                    .cmp(&a_channel_update_info.inbound_liquidity)
+                    .then(
+                        b_channel_info
+                            .capacity()
+                            .cmp(&a_channel_info.capacity())
+                            .then(
+                                b_channel_info
+                                    .channel_last_update_time()
+                                    .cmp(&a_channel_info.channel_last_update_time()),
+                            ),
+                    )
+            },
+        );
         channels.into_iter()
     }
 
@@ -904,20 +1070,10 @@ where
                     continue;
                 }
 
-                // if this is a direct channel, try to load the channel actor state for balance
-                if from == self.source || to == self.source {
-                    if let Some(state) = self
-                        .store
-                        .get_channel_state_by_outpoint(&channel_info.out_point())
-                    {
-                        let balance = if from == self.source {
-                            state.to_local_amount
-                        } else {
-                            state.to_remote_amount
-                        };
-                        if amount_to_send > balance {
-                            continue;
-                        }
+                // If we already know the balance of the channel, check if we can send the amount.
+                if let Some(balance) = channel_update.inbound_liquidity {
+                    if amount_to_send > balance {
+                        continue;
                     }
                 }
 
diff --git a/src/fiber/network.rs b/src/fiber/network.rs
index 28a00fbcd..3c6d762ee 100644
--- a/src/fiber/network.rs
+++ b/src/fiber/network.rs
@@ -48,7 +48,7 @@ use tracing::{debug, error, info, trace, warn};
 use super::channel::{
     get_funding_and_reserved_amount, occupied_capacity, AcceptChannelParameter, ChannelActor,
     ChannelActorMessage, ChannelActorStateStore, ChannelCommand, ChannelCommandWithId,
-    ChannelEvent, ChannelInitializationParameter, ChannelState, ChannelSubscribers,
+    ChannelEvent, ChannelInitializationParameter, ChannelState, ChannelSubscribers, ChannelTlcInfo,
     OpenChannelParameter, ProcessingChannelError, ProcessingChannelResult, PublicChannelInfo,
     RevocationData, SettlementData, ShuttingDownFlags, DEFAULT_COMMITMENT_FEE_RATE,
     DEFAULT_FEE_RATE, DEFAULT_MAX_TLC_VALUE_IN_FLIGHT, MAX_COMMITMENT_DELAY_EPOCHS,
@@ -57,7 +57,7 @@ use super::channel::{
 use super::config::{AnnouncedNodeName, MIN_TLC_EXPIRY_DELTA};
 use super::fee::calculate_commitment_tx_fee;
 use super::gossip::{GossipActorMessage, GossipMessageStore, GossipMessageUpdates};
-use super::graph::{NetworkGraph, NetworkGraphStateStore, SessionRoute};
+use super::graph::{NetworkGraph, NetworkGraphStateStore, OwnedChannelUpdateEvent, SessionRoute};
 use super::key::blake2b_hash_with_salt;
 use super::types::{
     BroadcastMessage, BroadcastMessageQuery, BroadcastMessageWithTimestamp, EcdsaSignature,
@@ -652,6 +652,9 @@ pub enum NetworkActorEvent {
         Option<(ProcessingChannelError, TlcErr)>,
         Option<(Hash256, u64)>,
     ),
+
+    // An owned channel is updated.
+    OwnedChannelUpdateEvent(OwnedChannelUpdateEvent),
 }
 
 #[derive(Debug)]
@@ -954,6 +957,19 @@ where
                 let mut graph = self.network_graph.write().await;
                 graph.update_for_messages(gossip_message_updates.messages);
             }
+            NetworkActorEvent::OwnedChannelUpdateEvent(owned_channel_update_event) => {
+                let mut graph = self.network_graph.write().await;
+                debug!(
+                    "Received owned channel update event: {:?}",
+                    owned_channel_update_event
+                );
+                let is_down =
+                    matches!(owned_channel_update_event, OwnedChannelUpdateEvent::Down(_));
+                graph.process_owned_channel_update_event(owned_channel_update_event);
+                if is_down {
+                    debug!("Owned channel is down");
+                }
+            }
         }
         Ok(())
     }
@@ -1584,12 +1600,8 @@ where
         payment_session: &mut PaymentSession,
         payment_data: &SendPaymentData,
     ) -> Result<Vec<PaymentHopData>, Error> {
-        match self
-            .network_graph
-            .read()
-            .await
-            .build_route(payment_data.clone())
-        {
+        let graph = self.network_graph.read().await;
+        match graph.build_route(payment_data.clone()) {
             Err(e) => {
                 let error = format!("Failed to build route, {}", e);
                 self.set_payment_fail_with_error(payment_session, &error);
@@ -2099,11 +2111,12 @@ where
             ChannelInitializationParameter::OpenChannel(OpenChannelParameter {
                 funding_amount,
                 seed,
-                public_channel_info: public.then_some(PublicChannelInfo::new(
+                tlc_info: ChannelTlcInfo::new(
                     tlc_min_value.unwrap_or(self.tlc_min_value),
                     tlc_expiry_delta.unwrap_or(self.tlc_expiry_delta),
                     tlc_fee_proportional_millionths.unwrap_or(self.tlc_fee_proportional_millionths),
-                )),
+                ),
+                public_channel_info: public.then_some(PublicChannelInfo::new()),
                 funding_udt_type_script,
                 shutdown_script,
                 channel_id_sender: tx,
@@ -2185,11 +2198,12 @@ where
             ChannelInitializationParameter::AcceptChannel(AcceptChannelParameter {
                 funding_amount,
                 reserved_ckb_amount,
-                public_channel_info: open_channel.is_public().then_some(PublicChannelInfo::new(
+                tlc_info: ChannelTlcInfo::new(
                     min_tlc_value.unwrap_or(self.tlc_min_value),
                     tlc_expiry_delta.unwrap_or(self.tlc_expiry_delta),
                     tlc_fee_proportional_millionths.unwrap_or(self.tlc_fee_proportional_millionths),
-                )),
+                ),
+                public_channel_info: open_channel.is_public().then_some(PublicChannelInfo::new()),
                 seed,
                 open_channel,
                 shutdown_script,
diff --git a/src/fiber/schema/fiber.mol b/src/fiber/schema/fiber.mol
index e454c1c3c..66082171f 100644
--- a/src/fiber/schema/fiber.mol
+++ b/src/fiber/schema/fiber.mol
@@ -95,6 +95,16 @@ struct ClosingSigned {
     partial_signature:  Byte32,
 }
 
+struct UpdateTlcInfo {
+    channel_id: Byte32,
+    timestamp: Uint64,
+    channel_flags: Uint32,
+    tlc_expiry_delta: Uint64,
+    tlc_minimum_value: Uint128,
+    tlc_maximum_value: Uint128,
+    tlc_fee_proportional_millionths: Uint128,
+}
+
 table AddTlc {
     channel_id:     Byte32,
     tlc_id:         Uint64,
@@ -180,6 +190,7 @@ union FiberMessage {
     TxAckRBF,
     CommitmentSigned,
     ChannelReady,
+    UpdateTlcInfo,
     AddTlc,
     RemoveTlc,
     RevokeAndAck,
diff --git a/src/fiber/tests/channel.rs b/src/fiber/tests/channel.rs
index 391430239..decfb1109 100644
--- a/src/fiber/tests/channel.rs
+++ b/src/fiber/tests/channel.rs
@@ -1,11 +1,11 @@
 use super::test_utils::{init_tracing, NetworkNode};
 use crate::fiber::channel::UpdateCommand;
 use crate::fiber::config::MAX_PAYMENT_TLC_EXPIRY_LIMIT;
-use crate::fiber::graph::PaymentSessionStatus;
+use crate::fiber::graph::{ChannelInfo, PaymentSessionStatus};
 use crate::fiber::network::{DebugEvent, SendPaymentCommand};
 use crate::fiber::tests::test_utils::*;
 use crate::fiber::types::{
-    Hash256, PaymentHopData, PeeledOnionPacket, TlcErrorCode, NO_SHARED_SECRET,
+    Hash256, PaymentHopData, PeeledOnionPacket, Pubkey, TlcErrorCode, NO_SHARED_SECRET,
 };
 use crate::invoice::{CkbInvoiceStatus, Currency, InvoiceBuilder};
 use crate::{
@@ -174,6 +174,36 @@ async fn test_create_private_channel() {
     .await;
 }
 
+#[tokio::test]
+async fn test_create_channel_with_remote_tlc_info() {
+    async fn test(public: bool) {
+        let node_a_funding_amount = 100000000000;
+        let node_b_funding_amount = 6200000000;
+
+        let (node_a, node_b, channel_id, _) = NetworkNode::new_2_nodes_with_established_channel(
+            node_a_funding_amount,
+            node_b_funding_amount,
+            public,
+        )
+        .await;
+
+        let node_a_channel_state = node_a.store.get_channel_actor_state(&channel_id).unwrap();
+        let node_b_channel_state = node_b.store.get_channel_actor_state(&channel_id).unwrap();
+
+        assert_eq!(
+            Some(node_a_channel_state.local_tlc_info),
+            node_b_channel_state.remote_tlc_info
+        );
+        assert_eq!(
+            Some(node_b_channel_state.local_tlc_info),
+            node_a_channel_state.remote_tlc_info
+        );
+    }
+
+    test(true).await;
+    test(false).await;
+}
+
 #[tokio::test]
 async fn test_create_public_channel() {
     init_tracing();
@@ -189,10 +219,7 @@ async fn test_create_public_channel() {
     .await;
 }
 
-#[tokio::test]
-async fn test_public_channel_saved_to_the_owner_graph() {
-    init_tracing();
-
+async fn do_test_owned_channel_saved_to_the_owner_graph(public: bool) {
     let node1_funding_amount = 100000000000;
     let node2_funding_amount = 6200000000;
 
@@ -200,12 +227,12 @@ async fn test_public_channel_saved_to_the_owner_graph() {
         NetworkNode::new_2_nodes_with_established_channel(
             node1_funding_amount,
             node2_funding_amount,
-            true,
+            public,
         )
         .await;
 
     // Wait for the channel announcement to be broadcasted
-    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
+    tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
 
     let node1_id = node1.peer_id.clone();
     node1.stop().await;
@@ -219,6 +246,8 @@ async fn test_public_channel_saved_to_the_owner_graph() {
         HashSet::from([node1_channel.node1_peerid(), node1_channel.node2_peerid()]),
         HashSet::from([node1_id.clone(), node2_id.clone()])
     );
+    assert_ne!(node1_channel.update_of_node1, None);
+    assert_ne!(node1_channel.update_of_node2, None);
     let node1_nodes = node1.get_network_graph_nodes().await;
     assert_eq!(node1_nodes.len(), 2);
     for node in node1_nodes {
@@ -228,6 +257,8 @@ async fn test_public_channel_saved_to_the_owner_graph() {
     let node2_channels = node2.get_network_graph_channels().await;
     assert_eq!(node2_channels.len(), 1);
     let node2_channel = &node2_channels[0];
+    assert_ne!(node2_channel.update_of_node1, None);
+    assert_ne!(node2_channel.update_of_node2, None);
     assert_eq!(
         HashSet::from([node2_channel.node1_peerid(), node2_channel.node2_peerid()]),
         HashSet::from([node1_id, node2_id])
@@ -239,6 +270,355 @@ async fn test_public_channel_saved_to_the_owner_graph() {
     }
 }
 
+#[tokio::test]
+async fn test_owned_public_channel_saved_to_the_owner_graph() {
+    do_test_owned_channel_saved_to_the_owner_graph(true).await;
+}
+
+#[tokio::test]
+async fn test_owned_private_channel_saved_to_the_owner_graph() {
+    do_test_owned_channel_saved_to_the_owner_graph(false).await;
+}
+
+async fn do_test_owned_channel_removed_from_graph_on_disconnected(public: bool) {
+    let node1_funding_amount = 100000000000;
+    let node2_funding_amount = 6200000000;
+
+    let (mut node1, mut node2, _new_channel_id, _) =
+        NetworkNode::new_2_nodes_with_established_channel(
+            node1_funding_amount,
+            node2_funding_amount,
+            public,
+        )
+        .await;
+
+    let node1_id = node1.peer_id.clone();
+    let node2_id = node2.peer_id.clone();
+
+    let node1_channels = node1.get_network_graph_channels().await;
+    assert_ne!(node1_channels, vec![]);
+    let node2_channels = node2.get_network_graph_channels().await;
+    assert_ne!(node2_channels, vec![]);
+
+    node1
+        .network_actor
+        .send_message(NetworkActorMessage::new_command(
+            NetworkActorCommand::DisconnectPeer(node2_id.clone()),
+        ))
+        .expect("node_a alive");
+
+    node1
+        .expect_event(|event| match event {
+            NetworkServiceEvent::PeerDisConnected(peer_id, _) => {
+                assert_eq!(peer_id, &node2_id);
+                true
+            }
+            _ => false,
+        })
+        .await;
+
+    node2
+        .expect_event(|event| match event {
+            NetworkServiceEvent::PeerDisConnected(peer_id, _) => {
+                assert_eq!(peer_id, &node1_id);
+                true
+            }
+            _ => false,
+        })
+        .await;
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+    let node1_channels = node1.get_network_graph_channels().await;
+    assert_eq!(node1_channels, vec![]);
+    let node2_channels = node2.get_network_graph_channels().await;
+    assert_eq!(node2_channels, vec![]);
+}
+
+#[tokio::test]
+async fn test_owned_channel_removed_from_graph_on_disconnected_public_channel() {
+    do_test_owned_channel_removed_from_graph_on_disconnected(true).await;
+}
+
+#[tokio::test]
+async fn test_owned_channel_removed_from_graph_on_disconnected_private_channel() {
+    do_test_owned_channel_removed_from_graph_on_disconnected(false).await;
+}
+
+async fn do_test_owned_channel_saved_to_graph_on_reconnected(public: bool) {
+    let node1_funding_amount = 100000000000;
+    let node2_funding_amount = 6200000000;
+
+    let (mut node1, mut node2, _new_channel_id, _) =
+        NetworkNode::new_2_nodes_with_established_channel(
+            node1_funding_amount,
+            node2_funding_amount,
+            public,
+        )
+        .await;
+
+    let node1_id = node1.peer_id.clone();
+    let node2_id = node2.peer_id.clone();
+
+    let node1_channels = node1.get_network_graph_channels().await;
+    assert_ne!(node1_channels, vec![]);
+    let node2_channels = node2.get_network_graph_channels().await;
+    assert_ne!(node2_channels, vec![]);
+
+    node1
+        .network_actor
+        .send_message(NetworkActorMessage::new_command(
+            NetworkActorCommand::DisconnectPeer(node2_id.clone()),
+        ))
+        .expect("node_a alive");
+
+    node1
+        .expect_event(|event| match event {
+            NetworkServiceEvent::PeerDisConnected(peer_id, _) => {
+                assert_eq!(peer_id, &node2_id);
+                true
+            }
+            _ => false,
+        })
+        .await;
+
+    node2
+        .expect_event(|event| match event {
+            NetworkServiceEvent::PeerDisConnected(peer_id, _) => {
+                assert_eq!(peer_id, &node1_id);
+                true
+            }
+            _ => false,
+        })
+        .await;
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+    let node1_channels = node1.get_network_graph_channels().await;
+    assert_eq!(node1_channels, vec![]);
+    let node2_channels = node2.get_network_graph_channels().await;
+    assert_eq!(node2_channels, vec![]);
+
+    // Don't use `connect_to` here as that may consume the `ChannelCreated` event.
+    // This is due to tentacle connection is async. We may actually send
+    // the `ChannelCreated` event before the `PeerConnected` event.
+    node1.connect_to_nonblocking(&node2).await;
+
+    node1
+        .expect_event(|event| match event {
+            NetworkServiceEvent::ChannelCreated(peer_id, channel_id) => {
+                println!("A channel ({:?}) to {:?} create", channel_id, peer_id);
+                assert_eq!(peer_id, &node2_id);
+                true
+            }
+            _ => false,
+        })
+        .await;
+
+    node2
+        .expect_event(|event| match event {
+            NetworkServiceEvent::ChannelCreated(peer_id, channel_id) => {
+                println!("A channel ({:?}) to {:?} create", channel_id, peer_id);
+                assert_eq!(peer_id, &node1_id);
+                true
+            }
+            _ => false,
+        })
+        .await;
+
+    tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+    let node1_channels = node1.get_network_graph_channels().await;
+    assert_ne!(node1_channels, vec![]);
+    let node2_channels = node2.get_network_graph_channels().await;
+    assert_ne!(node2_channels, vec![]);
+}
+
+#[tokio::test]
+async fn test_owned_channel_saved_to_graph_on_reconnected_public_channel() {
+    do_test_owned_channel_saved_to_graph_on_reconnected(true).await;
+}
+
+#[tokio::test]
+async fn test_owned_channel_saved_to_graph_on_reconnected_private_channel() {
+    do_test_owned_channel_saved_to_graph_on_reconnected(false).await;
+}
+
+async fn do_test_update_graph_balance_after_payment(public: bool) {
+    init_tracing();
+
+    let _span = tracing::info_span!("node", node = "test").entered();
+    let node_a_funding_amount = 100000000000;
+    let node_b_funding_amount = 6200000000;
+
+    let (node_a, node_b, new_channel_id) =
+        create_nodes_with_established_channel(node_a_funding_amount, node_b_funding_amount, public)
+            .await;
+    let node_a_pubkey = node_a.pubkey;
+    let node_b_pubkey = node_b.pubkey;
+
+    // Wait for the channel announcement to be broadcasted
+    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
+
+    let test_channel_info = |channels: Vec<ChannelInfo>,
+                             node_a_pubkey: Pubkey,
+                             node_b_pubkey: Pubkey,
+                             node_a_balance: u128,
+                             node_b_balance: u128| {
+        assert_eq!(channels.len(), 1);
+        let channel = &channels[0];
+        assert_ne!(channel.update_of_node1, None);
+        assert_ne!(channel.update_of_node2, None);
+        assert_ne!(channel.get_channel_update_of(node_a_pubkey), None);
+        assert_ne!(channel.get_channel_update_of(node_b_pubkey), None);
+        assert_eq!(
+            channel
+                .get_channel_update_of(node_a_pubkey)
+                .unwrap()
+                .inbound_liquidity,
+            Some(node_b_balance)
+        );
+        assert_eq!(
+            channel
+                .get_channel_update_of(node_b_pubkey)
+                .unwrap()
+                .inbound_liquidity,
+            Some(node_a_balance)
+        );
+    };
+
+    let node_a_old_balance = node_a.get_local_balance_from_channel(new_channel_id);
+    let node_b_old_balance = node_b.get_local_balance_from_channel(new_channel_id);
+    let node_a_old_channels = node_a.get_network_graph_channels().await;
+    let node_b_old_channels = node_b.get_network_graph_channels().await;
+    test_channel_info(
+        node_a_old_channels,
+        node_a_pubkey,
+        node_b_pubkey,
+        node_a_old_balance,
+        node_b_old_balance,
+    );
+    test_channel_info(
+        node_b_old_channels,
+        node_a_pubkey,
+        node_b_pubkey,
+        node_a_old_balance,
+        node_b_old_balance,
+    );
+
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_b_pubkey),
+                amount: Some(10000),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
+    };
+    let res1 = call!(node_a.network_actor, message)
+        .expect("node_a alive")
+        .unwrap();
+    // this is the payment_hash generated by keysend
+    assert_eq!(res1.status, PaymentSessionStatus::Created);
+    let payment_hash1 = res1.payment_hash;
+
+    // the second payment is send from node_b to node_a
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::SendPayment(
+            SendPaymentCommand {
+                target_pubkey: Some(node_a_pubkey),
+                amount: Some(9999),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                invoice: None,
+                timeout: None,
+                tlc_expiry_limit: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            },
+            rpc_reply,
+        ))
+    };
+    let res2 = call!(node_b.network_actor, message)
+        .expect("node_a alive")
+        .unwrap();
+    // this is the payment_hash generated by keysend
+    assert_eq!(res2.status, PaymentSessionStatus::Created);
+    let payment_hash2 = res2.payment_hash;
+
+    // sleep for 2 seconds to make sure the payment is processed
+    tokio::time::sleep(tokio::time::Duration::from_millis(2000)).await;
+
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash1, rpc_reply))
+    };
+    let res = call!(node_a.network_actor, message)
+        .expect("node_a alive")
+        .unwrap();
+    assert_eq!(res.status, PaymentSessionStatus::Success);
+    assert_eq!(res.failed_error, None);
+
+    let message = |rpc_reply| -> NetworkActorMessage {
+        NetworkActorMessage::Command(NetworkActorCommand::GetPayment(payment_hash2, rpc_reply))
+    };
+    let res = call!(node_b.network_actor, message)
+        .expect("node_a alive")
+        .unwrap();
+
+    assert_eq!(res.status, PaymentSessionStatus::Success);
+    assert_eq!(res.failed_error, None);
+
+    let node_a_new_balance = node_a.get_local_balance_from_channel(new_channel_id);
+    let node_b_new_balance = node_b.get_local_balance_from_channel(new_channel_id);
+
+    // assert the balance is right,
+    // node_a send 10000 to node_b, and node_b send 9999 to node_a
+    // so the balance should be node_a_old_balance - 1, node_b_old_balance + 1
+    assert_eq!(node_a_new_balance, node_a_old_balance - 1);
+    assert_eq!(node_b_new_balance, node_b_old_balance + 1);
+
+    let node_a_new_channels = node_a.get_network_graph_channels().await;
+    let node_b_new_channels = node_b.get_network_graph_channels().await;
+    test_channel_info(
+        node_a_new_channels,
+        node_a_pubkey,
+        node_b_pubkey,
+        node_a_new_balance,
+        node_b_new_balance,
+    );
+    test_channel_info(
+        node_b_new_channels,
+        node_a_pubkey,
+        node_b_pubkey,
+        node_a_new_balance,
+        node_b_new_balance,
+    );
+}
+
+#[tokio::test]
+async fn test_update_graph_balance_after_payment_public_channel() {
+    do_test_update_graph_balance_after_payment(true).await;
+}
+
+#[tokio::test]
+async fn test_update_graph_balance_after_payment_private_channel() {
+    do_test_update_graph_balance_after_payment(false).await;
+}
+
 #[tokio::test]
 async fn test_public_channel_saved_to_the_other_nodes_graph() {
     init_tracing();
@@ -4622,8 +5002,8 @@ async fn test_send_payment_with_disable_channel() {
     // sleep for a while
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
 
-    // begin to set channel disable
-    node_2.disable_channel(channels[1]).await;
+    // begin to set channel disable, but do not notify the network
+    node_2.disable_channel_stealthy(channels[1]).await;
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
 
     let message = |rpc_reply| -> NetworkActorMessage {
diff --git a/src/fiber/tests/gossip.rs b/src/fiber/tests/gossip.rs
index 0ec776798..55d3fc9e1 100644
--- a/src/fiber/tests/gossip.rs
+++ b/src/fiber/tests/gossip.rs
@@ -17,7 +17,7 @@ use tentacle::{
 use tokio::{spawn, sync::RwLock};
 
 use crate::fiber::tests::test_utils::{establish_channel_between_nodes, NetworkNode};
-use crate::fiber::types::NodeAnnouncement;
+use crate::fiber::types::{ChannelUpdateChannelFlags, NodeAnnouncement};
 use crate::{
     ckb::{
         tests::{actor::create_mock_chain_actor, test_utils::submit_tx},
@@ -309,8 +309,18 @@ async fn test_saving_channel_update_after_saving_channel_announcement() {
         .get_latest_channel_announcement(channel_context.channel_outpoint());
     assert_ne!(new_announcement, None);
     for channel_update in [
-        channel_context.create_channel_update_of_node1(0, 42, 42, 42),
-        channel_context.create_channel_update_of_node2(0, 42, 42, 42),
+        channel_context.create_channel_update_of_node1(
+            ChannelUpdateChannelFlags::empty(),
+            42,
+            42,
+            42,
+        ),
+        channel_context.create_channel_update_of_node2(
+            ChannelUpdateChannelFlags::empty(),
+            42,
+            42,
+            42,
+        ),
     ] {
         context.save_message(BroadcastMessage::ChannelUpdate(channel_update.clone()));
     }
@@ -329,8 +339,18 @@ async fn test_saving_channel_update_before_saving_channel_announcement() {
     let channel_context = ChannelTestContext::gen();
 
     for channel_update in [
-        channel_context.create_channel_update_of_node1(0, 42, 42, 42),
-        channel_context.create_channel_update_of_node2(0, 42, 42, 42),
+        channel_context.create_channel_update_of_node1(
+            ChannelUpdateChannelFlags::empty(),
+            42,
+            42,
+            42,
+        ),
+        channel_context.create_channel_update_of_node2(
+            ChannelUpdateChannelFlags::empty(),
+            42,
+            42,
+            42,
+        ),
     ] {
         context.save_message(BroadcastMessage::ChannelUpdate(channel_update.clone()));
     }
@@ -375,8 +395,18 @@ async fn test_saving_invalid_channel_update() {
         .get_latest_channel_announcement(channel_context.channel_outpoint());
     assert_ne!(new_announcement, None);
     for mut channel_update in [
-        channel_context.create_channel_update_of_node1(0, 42, 42, 42),
-        channel_context.create_channel_update_of_node2(0, 42, 42, 42),
+        channel_context.create_channel_update_of_node1(
+            ChannelUpdateChannelFlags::empty(),
+            42,
+            42,
+            42,
+        ),
+        channel_context.create_channel_update_of_node2(
+            ChannelUpdateChannelFlags::empty(),
+            42,
+            42,
+            42,
+        ),
     ] {
         channel_update.signature = Some(create_invalid_ecdsa_signature());
         context.save_message(BroadcastMessage::ChannelUpdate(channel_update.clone()));
@@ -406,8 +436,18 @@ async fn test_saving_channel_update_independency() {
             .get_latest_channel_announcement(channel_context.channel_outpoint());
         assert_ne!(new_announcement, None);
         for mut channel_update in [
-            channel_context.create_channel_update_of_node1(0, 42, 42, 42),
-            channel_context.create_channel_update_of_node2(0, 42, 42, 42),
+            channel_context.create_channel_update_of_node1(
+                ChannelUpdateChannelFlags::empty(),
+                42,
+                42,
+                42,
+            ),
+            channel_context.create_channel_update_of_node2(
+                ChannelUpdateChannelFlags::empty(),
+                42,
+                42,
+                42,
+            ),
         ] {
             if channel_update.is_update_of_node_1() && node1_has_invalid_signature {
                 channel_update.signature = Some(create_invalid_ecdsa_signature());
@@ -485,8 +525,18 @@ async fn test_saving_channel_update_with_invalid_channel_announcement() {
         .get_latest_channel_announcement(channel_context.channel_outpoint());
     assert_eq!(new_announcement, None);
     for channel_update in [
-        channel_context.create_channel_update_of_node1(0, 42, 42, 42),
-        channel_context.create_channel_update_of_node2(0, 42, 42, 42),
+        channel_context.create_channel_update_of_node1(
+            ChannelUpdateChannelFlags::empty(),
+            42,
+            42,
+            42,
+        ),
+        channel_context.create_channel_update_of_node2(
+            ChannelUpdateChannelFlags::empty(),
+            42,
+            42,
+            42,
+        ),
     ] {
         context.save_message(BroadcastMessage::ChannelUpdate(channel_update.clone()));
     }
diff --git a/src/fiber/tests/graph.rs b/src/fiber/tests/graph.rs
index 2986b35a3..fd5d46de9 100644
--- a/src/fiber/tests/graph.rs
+++ b/src/fiber/tests/graph.rs
@@ -1,8 +1,7 @@
-use crate::fiber::channel::{MESSAGE_OF_NODE1_FLAG, MESSAGE_OF_NODE2_FLAG};
 use crate::fiber::config::MAX_PAYMENT_TLC_EXPIRY_LIMIT;
 use crate::fiber::gossip::GossipMessageStore;
 use crate::fiber::graph::{PathFindError, SessionRoute};
-use crate::fiber::types::Pubkey;
+use crate::fiber::types::{ChannelUpdateChannelFlags, ChannelUpdateMessageFlags, Pubkey};
 use crate::now_timestamp_as_millis_u64;
 use crate::{
     fiber::{
@@ -67,7 +66,8 @@ impl MockNetworkGraph {
                 0,
             ));
         }
-        let graph = NetworkGraph::new(store.clone(), public_key1.into(), true);
+        let mut graph = NetworkGraph::new(store.clone(), public_key1.into(), true);
+        graph.always_process_gossip_message = true;
 
         Self {
             keys: keypairs.into_iter().map(|x| x.1).collect(),
@@ -142,11 +142,11 @@ impl MockNetworkGraph {
             channel_outpoint.clone(),
             now_timestamp_as_millis_u64(),
             if node_a_is_node1 {
-                MESSAGE_OF_NODE2_FLAG
+                ChannelUpdateMessageFlags::UPDATE_OF_NODE2
             } else {
-                MESSAGE_OF_NODE1_FLAG
+                ChannelUpdateMessageFlags::UPDATE_OF_NODE1
             },
-            0,
+            ChannelUpdateChannelFlags::empty(),
             TLC_EXPIRY_DELTA_IN_TESTS,
             min_tlc_value.unwrap_or(0),
             fee_rate.unwrap_or(0),
@@ -156,11 +156,11 @@ impl MockNetworkGraph {
                 channel_outpoint.clone(),
                 now_timestamp_as_millis_u64(),
                 if node_a_is_node1 {
-                    MESSAGE_OF_NODE1_FLAG
+                    ChannelUpdateMessageFlags::UPDATE_OF_NODE1
                 } else {
-                    MESSAGE_OF_NODE2_FLAG
+                    ChannelUpdateMessageFlags::UPDATE_OF_NODE2
                 },
-                0,
+                ChannelUpdateChannelFlags::empty(),
                 22,
                 min_tlc_value.unwrap_or(0),
                 fee_rate,
diff --git a/src/fiber/tests/network.rs b/src/fiber/tests/network.rs
index 329f317a0..31b2d6d76 100644
--- a/src/fiber/tests/network.rs
+++ b/src/fiber/tests/network.rs
@@ -1,20 +1,20 @@
 use super::test_utils::{init_tracing, NetworkNode};
 use crate::{
     fiber::{
-        channel::{ShutdownInfo, MESSAGE_OF_NODE1_FLAG, MESSAGE_OF_NODE2_FLAG},
+        channel::ShutdownInfo,
         config::DEFAULT_TLC_EXPIRY_DELTA,
-        gossip::GossipMessageStore,
         graph::ChannelUpdateInfo,
         network::{NetworkActorStateStore, SendPaymentCommand, SendPaymentData},
         tests::test_utils::NetworkNodeConfigBuilder,
         types::{
-            BroadcastMessage, ChannelAnnouncement, ChannelUpdate, NodeAnnouncement, Privkey, Pubkey,
+            BroadcastMessage, ChannelAnnouncement, ChannelUpdateChannelFlags, NodeAnnouncement,
+            Privkey, Pubkey,
         },
         NetworkActorCommand, NetworkActorEvent, NetworkActorMessage,
     },
     gen_rand_fiber_public_key, gen_rand_secp256k1_keypair_tuple, gen_rand_sha256_hash,
     invoice::InvoiceBuilder,
-    now_timestamp_as_millis_u64, NetworkServiceEvent,
+    now_timestamp_as_millis_u64, ChannelTestContext, NetworkServiceEvent,
 };
 use ckb_hash::blake2b_256;
 use ckb_jsonrpc_types::Status;
@@ -253,87 +253,58 @@ async fn test_sync_channel_announcement_on_startup() {
     assert!(!channels.is_empty());
 }
 
-async fn create_a_channel() -> (NetworkNode, ChannelAnnouncement, Privkey, Privkey) {
-    init_tracing();
-
-    let node_a_funding_amount = 100000000000;
-    let node_b_funding_amount = 6200000000;
-
-    let (node1, mut node2, _, funding_tx) = NetworkNode::new_2_nodes_with_established_channel(
-        node_a_funding_amount,
-        node_b_funding_amount,
-        true,
-    )
-    .await;
-
-    // Wait for the broadcast message to be processed.
-    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-    let outpoint = funding_tx.output_pts_iter().next().unwrap();
-    node2.stop().await;
-
-    let (_, channel_announcement) = node2
-        .store
-        .get_latest_channel_announcement(&outpoint)
-        .expect("get channel");
-
-    let node1_priv_key = node1.get_private_key().clone();
-    let node2_priv_key = node2.get_private_key().clone();
-    if channel_announcement.node1_id == node1_priv_key.pubkey() {
-        (node1, channel_announcement, node1_priv_key, node2_priv_key)
-    } else {
-        (node1, channel_announcement, node2_priv_key, node1_priv_key)
-    }
-}
-
 #[tokio::test]
 async fn test_node1_node2_channel_update() {
-    let (node, channel_announcement, sk1, sk2) = create_a_channel().await;
-
-    let create_channel_update = |timestamp: u64, message_flags: u32, key: Privkey| {
-        let mut channel_update = ChannelUpdate::new_unsigned(
-            channel_announcement.out_point().clone(),
-            timestamp,
-            message_flags,
-            0,
-            42,
-            0,
-            10,
-        );
-
-        channel_update.signature = Some(key.sign(channel_update.message_to_sign()));
-        node.network_actor
-            .send_message(NetworkActorMessage::Event(
-                NetworkActorEvent::GossipMessage(
-                    get_test_peer_id(),
-                    BroadcastMessage::ChannelUpdate(channel_update.clone())
-                        .create_broadcast_messages_filter_result(),
-                ),
-            ))
-            .expect("send message to network actor");
-        channel_update
-    };
+    let channel_context = ChannelTestContext::gen();
+    let funding_tx = channel_context.funding_tx.clone();
+    let out_point = channel_context.channel_outpoint().clone();
+    let channel_announcement = channel_context.channel_announcement.clone();
+    let mut node = NetworkNode::new().await;
+    node.submit_tx(funding_tx).await;
+    node.network_actor
+        .send_message(NetworkActorMessage::Event(
+            NetworkActorEvent::GossipMessage(
+                get_test_peer_id(),
+                BroadcastMessage::ChannelAnnouncement(channel_announcement)
+                    .create_broadcast_messages_filter_result(),
+            ),
+        ))
+        .expect("send message to network actor");
+    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
 
     let channel_update_of_node1 =
-        create_channel_update(now_timestamp_as_millis_u64(), MESSAGE_OF_NODE1_FLAG, sk1);
+        channel_context.create_channel_update_of_node1(ChannelUpdateChannelFlags::empty(), 1, 1, 1);
+    node.network_actor
+        .send_message(NetworkActorMessage::Event(
+            NetworkActorEvent::GossipMessage(
+                get_test_peer_id(),
+                BroadcastMessage::ChannelUpdate(channel_update_of_node1.clone())
+                    .create_broadcast_messages_filter_result(),
+            ),
+        ))
+        .expect("send message to network actor");
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
 
-    let new_channel_info = node
-        .get_network_graph_channel(channel_announcement.out_point())
-        .await
-        .unwrap();
+    let new_channel_info = node.get_network_graph_channel(&out_point).await.unwrap();
     assert_eq!(
         new_channel_info.update_of_node1,
         Some(ChannelUpdateInfo::from(&channel_update_of_node1))
     );
 
     let channel_update_of_node2 =
-        create_channel_update(now_timestamp_as_millis_u64(), MESSAGE_OF_NODE2_FLAG, sk2);
+        channel_context.create_channel_update_of_node2(ChannelUpdateChannelFlags::empty(), 2, 2, 2);
+    node.network_actor
+        .send_message(NetworkActorMessage::Event(
+            NetworkActorEvent::GossipMessage(
+                get_test_peer_id(),
+                BroadcastMessage::ChannelUpdate(channel_update_of_node2.clone())
+                    .create_broadcast_messages_filter_result(),
+            ),
+        ))
+        .expect("send message to network actor");
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
 
-    let new_channel_info = node
-        .get_network_graph_channel(channel_announcement.out_point())
-        .await
-        .unwrap();
+    let new_channel_info = node.get_network_graph_channel(&out_point).await.unwrap();
     assert_eq!(
         new_channel_info.update_of_node1,
         Some(ChannelUpdateInfo::from(&channel_update_of_node1))
@@ -346,40 +317,35 @@ async fn test_node1_node2_channel_update() {
 
 #[tokio::test]
 async fn test_channel_update_version() {
-    let (node, channel_info, sk1, sk2) = create_a_channel().await;
-
-    let create_channel_update = |key: &Privkey| {
-        let message_flag = if key == &sk1 {
-            MESSAGE_OF_NODE1_FLAG
-        } else {
-            MESSAGE_OF_NODE2_FLAG
-        };
-        let mut channel_update = ChannelUpdate::new_unsigned(
-            channel_info.out_point().clone(),
-            now_timestamp_as_millis_u64(),
-            message_flag,
-            0,
-            42,
-            0,
-            10,
-        );
-        tracing::debug!(
-            "Signing channel update: {:?} with key (pub {:?}) (pk1 {:?}) (pk2 {:?})",
-            &channel_update,
-            &key.pubkey(),
-            &sk1.pubkey(),
-            &sk2.pubkey()
-        );
-
-        channel_update.signature = Some(key.sign(channel_update.message_to_sign()));
-        channel_update
-    };
+    let channel_context = ChannelTestContext::gen();
+    let funding_tx = channel_context.funding_tx.clone();
+    let out_point = channel_context.channel_outpoint().clone();
+    let mut node = NetworkNode::new().await;
+    node.submit_tx(funding_tx).await;
+    node.network_actor
+        .send_message(NetworkActorMessage::Event(
+            NetworkActorEvent::GossipMessage(
+                get_test_peer_id(),
+                BroadcastMessage::ChannelAnnouncement(channel_context.channel_announcement.clone())
+                    .create_broadcast_messages_filter_result(),
+            ),
+        ))
+        .expect("send message to network actor");
+    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
 
-    let (channel_update_1, channel_update_2, channel_update_3) = (
-        create_channel_update(&sk1),
-        create_channel_update(&sk1),
-        create_channel_update(&sk1),
-    );
+    let mut channel_updates = vec![];
+    for i in 0u8..3 {
+        // Make sure the timestamp is different.
+        tokio::time::sleep(tokio::time::Duration::from_millis(3)).await;
+        channel_updates.push(channel_context.create_channel_update_of_node1(
+            ChannelUpdateChannelFlags::empty(),
+            i.into(),
+            i.into(),
+            i.into(),
+        ))
+    }
+    let [channel_update_1, channel_update_2, channel_update_3] =
+        channel_updates.try_into().expect("3 channel updates");
 
     node.network_actor
         .send_message(NetworkActorMessage::Event(
@@ -391,10 +357,7 @@ async fn test_channel_update_version() {
         ))
         .expect("send message to network actor");
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-    let new_channel_info = node
-        .get_network_graph_channel(channel_info.out_point())
-        .await
-        .unwrap();
+    let new_channel_info = node.get_network_graph_channel(&out_point).await.unwrap();
     assert_eq!(
         new_channel_info.update_of_node1,
         Some(ChannelUpdateInfo::from(&channel_update_2))
@@ -411,10 +374,7 @@ async fn test_channel_update_version() {
         ))
         .expect("send message to network actor");
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-    let new_channel_info = node
-        .get_network_graph_channel(channel_info.out_point())
-        .await
-        .unwrap();
+    let new_channel_info = node.get_network_graph_channel(&out_point).await.unwrap();
     assert_eq!(
         new_channel_info.update_of_node1,
         Some(ChannelUpdateInfo::from(&channel_update_2))
@@ -431,10 +391,7 @@ async fn test_channel_update_version() {
         ))
         .expect("send message to network actor");
     tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
-    let new_channel_info = node
-        .get_network_graph_channel(channel_info.out_point())
-        .await
-        .unwrap();
+    let new_channel_info = node.get_network_graph_channel(&out_point).await.unwrap();
     assert_eq!(
         new_channel_info.update_of_node1,
         Some(ChannelUpdateInfo::from(&channel_update_3))
diff --git a/src/fiber/tests/payment.rs b/src/fiber/tests/payment.rs
index db9fe7d47..01b1b39b6 100644
--- a/src/fiber/tests/payment.rs
+++ b/src/fiber/tests/payment.rs
@@ -10,6 +10,9 @@ use crate::fiber::NetworkActorCommand;
 use crate::fiber::NetworkActorMessage;
 use ractor::call;
 
+// This test will send two payments from node_0 to node_1, the first payment will run
+// with dry_run, the second payment will run without dry_run. Both payments will be successful.
+// But only one payment balance will be deducted from node_0.
 #[tokio::test]
 async fn test_send_payment_for_direct_channel_and_dry_run() {
     init_tracing();
@@ -17,15 +20,13 @@ async fn test_send_payment_for_direct_channel_and_dry_run() {
     // from https://github.com/nervosnetwork/fiber/issues/359
 
     let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
-        &[
-            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
-            ((0, 1), (MIN_RESERVED_CKB, MIN_RESERVED_CKB + 10000000000)),
-        ],
+        &[((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB))],
         2,
         true,
     )
     .await;
-    let [mut node_0, mut node_1] = nodes.try_into().expect("2 nodes");
+    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let channel = channels[0];
     let source_node = &mut node_0;
 
     let res = source_node
@@ -42,36 +43,195 @@ async fn test_send_payment_for_direct_channel_and_dry_run() {
     eprintln!("res: {:?}", res);
     assert!(res.is_ok());
     let payment_hash = res.unwrap().payment_hash;
-
     source_node.wait_until_success(payment_hash).await;
 
-    let res = node_1
-        .send_payment_keysend(&source_node, 10000000000, false)
+    let node_0_balance = source_node.get_local_balance_from_channel(channel);
+    let node_1_balance = node_1.get_local_balance_from_channel(channel);
+
+    // A -> B: 10000000000 use the first channel
+    assert_eq!(node_0_balance, 0);
+    assert_eq!(node_1_balance, 10000000000);
+}
+
+#[tokio::test]
+async fn test_send_payment_prefer_newer_channels() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+
+    let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+        ],
+        2,
+        true,
+    )
+    .await;
+    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &mut node_0;
+    let target_pubkey = node_1.pubkey.clone();
+
+    let res = source_node
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(target_pubkey.clone()),
+            amount: Some(10000000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: false,
+            hop_hints: None,
+            dry_run: false,
+        })
         .await;
 
     eprintln!("res: {:?}", res);
     assert!(res.is_ok());
-
-    // sleep for a while
     let payment_hash = res.unwrap().payment_hash;
-    node_1.wait_until_success(payment_hash).await;
-    node_1
-        .assert_payment_status(payment_hash, PaymentSessionStatus::Success, Some(1))
-        .await;
+    source_node.wait_until_success(payment_hash).await;
 
+    // We are using the second (newer) channel, so the first channel's balances are unchanged.
     let node_0_balance = source_node.get_local_balance_from_channel(channels[0]);
     let node_1_balance = node_1.get_local_balance_from_channel(channels[0]);
+    assert_eq!(node_0_balance, 10000000000);
+    assert_eq!(node_1_balance, 0);
 
-    // A -> B: 10000000000 use the first channel
+    // We are using the second (newer) channel, so the second channel's balances are changed.
+    let node_0_balance = source_node.get_local_balance_from_channel(channels[1]);
+    let node_1_balance = node_1.get_local_balance_from_channel(channels[1]);
     assert_eq!(node_0_balance, 0);
     assert_eq!(node_1_balance, 10000000000);
+}
 
+#[tokio::test]
+async fn test_send_payment_prefer_channels_with_larger_balance() {
+    init_tracing();
+    let _span = tracing::info_span!("node", node = "test").entered();
+
+    let (nodes, channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+        &[
+            // These two channnels have the same overall capacity, but the second channel has more balance for node_0.
+            (
+                (0, 1),
+                (MIN_RESERVED_CKB + 5000000000, MIN_RESERVED_CKB + 5000000000),
+            ),
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+        ],
+        2,
+        true,
+    )
+    .await;
+    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &mut node_0;
+    let target_pubkey = node_1.pubkey.clone();
+
+    let res = source_node
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(target_pubkey.clone()),
+            amount: Some(5000000000),
+            payment_hash: None,
+            final_tlc_expiry_delta: None,
+            tlc_expiry_limit: None,
+            invoice: None,
+            timeout: None,
+            max_fee_amount: None,
+            max_parts: None,
+            keysend: Some(true),
+            udt_type_script: None,
+            allow_self_payment: false,
+            hop_hints: None,
+            dry_run: false,
+        })
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+    let payment_hash = res.unwrap().payment_hash;
+    source_node.wait_until_success(payment_hash).await;
+
+    // We are using the second channel (with larger balance), so the first channel's balances are unchanged.
+    let node_0_balance = source_node.get_local_balance_from_channel(channels[0]);
+    let node_1_balance = node_1.get_local_balance_from_channel(channels[0]);
+    assert_eq!(node_0_balance, 5000000000);
+    assert_eq!(node_1_balance, 5000000000);
+
+    // We are using the second channel (with larger balance), so the second channel's balances are changed.
     let node_0_balance = source_node.get_local_balance_from_channel(channels[1]);
     let node_1_balance = node_1.get_local_balance_from_channel(channels[1]);
+    assert_eq!(node_0_balance, 5000000000);
+    assert_eq!(node_1_balance, 5000000000);
+}
 
-    // B -> A: 10000000000 use the second channel
-    assert_eq!(node_0_balance, 10000000000);
-    assert_eq!(node_1_balance, 0);
+#[tokio::test]
+async fn test_send_payment_over_private_channel() {
+    async fn test(amount_to_send: u128, is_payment_ok: bool) {
+        let (nodes, _channels) = create_n_nodes_with_index_and_amounts_with_established_channel(
+            &[((1, 2), (MIN_RESERVED_CKB + 20000000000, MIN_RESERVED_CKB))],
+            3,
+            true,
+        )
+        .await;
+        let [mut node1, mut node2, node3] = nodes.try_into().expect("3 nodes");
+
+        let (_new_channel_id, _funding_tx) = establish_channel_between_nodes(
+            &mut node1,
+            &mut node2,
+            false,
+            MIN_RESERVED_CKB + 20000000000,
+            MIN_RESERVED_CKB,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )
+        .await;
+
+        // sleep for a while
+        tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
+
+        let source_node = &mut node1;
+        let target_pubkey = node3.pubkey.clone();
+
+        let res = source_node
+            .send_payment(SendPaymentCommand {
+                target_pubkey: Some(target_pubkey.clone()),
+                amount: Some(amount_to_send),
+                payment_hash: None,
+                final_tlc_expiry_delta: None,
+                tlc_expiry_limit: None,
+                invoice: None,
+                timeout: None,
+                max_fee_amount: None,
+                max_parts: None,
+                keysend: Some(true),
+                udt_type_script: None,
+                allow_self_payment: false,
+                hop_hints: None,
+                dry_run: false,
+            })
+            .await;
+
+        eprintln!("res: {:?}", res);
+        if is_payment_ok {
+            assert!(res.is_ok());
+        } else {
+            assert!(res.is_err());
+        }
+    }
+
+    test(10000000000, true).await;
+    test(30000000000, false).await;
 }
 
 #[tokio::test]
@@ -1331,7 +1491,7 @@ async fn test_send_payment_middle_hop_stopped() {
         true,
     )
     .await;
-    let [mut node_0, _node_1, mut node_2, node_3, mut node_4] = nodes.try_into().expect("5 nodes");
+    let [mut node_0, _node_1, _node_2, node_3, mut node_4] = nodes.try_into().expect("5 nodes");
 
     // dry run node_0 -> node_3 will select  0 -> 4 -> 3
     let res = node_0
@@ -1345,32 +1505,8 @@ async fn test_send_payment_middle_hop_stopped() {
     node_4.stop().await;
     tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await;
 
-    let res = node_0
-        .send_payment_keysend(&node_3, 1000, true)
-        .await
-        .unwrap();
-    eprintln!("res: {:?}", res);
-    // when node_4 stopped, the first try path is still 0 -> 4 -> 3
-    // so the fee is 1
-    assert_eq!(res.fee, 1);
-
-    let res = node_0
-        .send_payment_keysend(&node_3, 1000, false)
-        .await
-        .unwrap();
-    eprintln!("res: {:?}", res);
-    assert_eq!(res.fee, 1);
-
-    node_0.wait_until_success(res.payment_hash).await;
-
-    // after the first payment try failed, the payment session will find another path
-    // 0 -> 1 -> 2 -> 3, so it will succeed, but the fee change from 1 to 3
-    let payment = node_0.get_payment_result(res.payment_hash).await;
-    assert_eq!(payment.fee, 3);
-    eprintln!("payment: {:?}", payment);
-
-    // node_2 stopped, payment will fail
-    node_2.stop().await;
+    // when node_4 stopped, node 0 learned that channel 0 -> 4 was not available
+    // so it will try another path 0 -> 1 -> 2 -> 3
     let res = node_0
         .send_payment_keysend(&node_3, 1000, false)
         .await
@@ -1378,7 +1514,7 @@ async fn test_send_payment_middle_hop_stopped() {
     eprintln!("res: {:?}", res);
     assert_eq!(res.fee, 3);
 
-    node_0.wait_until_failed(res.payment_hash).await;
+    node_0.wait_until_success(res.payment_hash).await;
 }
 
 #[tokio::test]
diff --git a/src/fiber/tests/test_utils.rs b/src/fiber/tests/test_utils.rs
index dbd299881..da3ff0b13 100644
--- a/src/fiber/tests/test_utils.rs
+++ b/src/fiber/tests/test_utils.rs
@@ -2,6 +2,7 @@ use crate::fiber::channel::ChannelActorState;
 use crate::fiber::channel::ChannelActorStateStore;
 use crate::fiber::channel::ChannelCommand;
 use crate::fiber::channel::ChannelCommandWithId;
+use crate::fiber::channel::ReloadParams;
 use crate::fiber::graph::NetworkGraphStateStore;
 use crate::fiber::graph::PaymentSession;
 use crate::fiber::graph::PaymentSessionStatus;
@@ -675,14 +676,18 @@ impl NetworkNode {
         res
     }
 
-    pub async fn update_channel_actor_state(&mut self, state: ChannelActorState) {
+    pub async fn update_channel_actor_state(
+        &mut self,
+        state: ChannelActorState,
+        reload_params: Option<ReloadParams>,
+    ) {
         let channel_id = state.id.clone();
         self.store.insert_channel_actor_state(state);
         self.network_actor
             .send_message(NetworkActorMessage::Command(
                 NetworkActorCommand::ControlFiberChannel(ChannelCommandWithId {
                     channel_id,
-                    command: ChannelCommand::ReloadState(),
+                    command: ChannelCommand::ReloadState(reload_params.unwrap_or_default()),
                 }),
             ))
             .expect("network actor is live");
@@ -696,7 +701,8 @@ impl NetworkNode {
     ) {
         let mut channel_actor_state = self.get_channel_actor_state(channel_id);
         channel_actor_state.to_local_amount = new_to_local_amount;
-        self.update_channel_actor_state(channel_actor_state).await;
+        self.update_channel_actor_state(channel_actor_state, None)
+            .await;
     }
 
     pub async fn update_channel_remote_balance(
@@ -706,15 +712,27 @@ impl NetworkNode {
     ) {
         let mut channel_actor_state = self.get_channel_actor_state(channel_id);
         channel_actor_state.to_remote_amount = new_to_remote_amount;
-        self.update_channel_actor_state(channel_actor_state).await;
+        self.update_channel_actor_state(channel_actor_state, None)
+            .await;
     }
 
     pub async fn disable_channel(&mut self, channel_id: Hash256) {
         let mut channel_actor_state = self.get_channel_actor_state(channel_id);
-        let mut public_info = channel_actor_state.public_channel_info.unwrap();
-        public_info.enabled = false;
-        channel_actor_state.public_channel_info = Some(public_info);
-        self.update_channel_actor_state(channel_actor_state).await;
+        channel_actor_state.local_tlc_info.enabled = false;
+        self.update_channel_actor_state(channel_actor_state, None)
+            .await;
+    }
+
+    pub async fn disable_channel_stealthy(&mut self, channel_id: Hash256) {
+        let mut channel_actor_state = self.get_channel_actor_state(channel_id);
+        channel_actor_state.local_tlc_info.enabled = false;
+        self.update_channel_actor_state(
+            channel_actor_state,
+            Some(ReloadParams {
+                notify_changes: false,
+            }),
+        )
+        .await;
     }
 
     pub fn get_payment_session(&self, payment_hash: Hash256) -> Option<PaymentSession> {
diff --git a/src/fiber/types.rs b/src/fiber/types.rs
index f5b92089f..9092dcc51 100644
--- a/src/fiber/types.rs
+++ b/src/fiber/types.rs
@@ -1,6 +1,4 @@
-use super::channel::{
-    ChannelFlags, ProcessingChannelError, CHANNEL_DISABLED_FLAG, MESSAGE_OF_NODE2_FLAG,
-};
+use super::channel::{ChannelFlags, ChannelTlcInfo, ProcessingChannelError};
 use super::config::AnnouncedNodeName;
 use super::gen::fiber::{
     self as molecule_fiber, ChannelUpdateOpt, PaymentPreimageOpt, PubNonce as Byte66, PubkeyOpt,
@@ -55,6 +53,20 @@ pub fn secp256k1_instance() -> &'static Secp256k1<All> {
     INSTANCE.get_or_init(Secp256k1::new)
 }
 
+bitflags::bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+    #[serde(transparent)]
+    pub struct ChannelUpdateChannelFlags: u32 {
+        const DISABLED = 1;
+    }
+    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+    #[serde(transparent)]
+    pub struct ChannelUpdateMessageFlags: u32 {
+        const UPDATE_OF_NODE1 = 0;
+        const UPDATE_OF_NODE2 = 1;
+    }
+}
+
 impl From<&Byte66> for PubNonce {
     fn from(value: &Byte66) -> Self {
         PubNonce::from_bytes(value.as_slice()).expect("PubNonce from Byte66")
@@ -999,6 +1011,64 @@ impl TryFrom<molecule_fiber::ClosingSigned> for ClosingSigned {
     }
 }
 
+#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+pub struct UpdateTlcInfo {
+    pub channel_id: Hash256,
+    pub timestamp: u64,
+    pub channel_flags: ChannelUpdateChannelFlags,
+    pub tlc_expiry_delta: u64,
+    pub tlc_minimum_value: u128,
+    pub tlc_maximum_value: u128,
+    pub tlc_fee_proportional_millionths: u128,
+}
+
+impl From<UpdateTlcInfo> for molecule_fiber::UpdateTlcInfo {
+    fn from(update_tlc_info: UpdateTlcInfo) -> Self {
+        molecule_fiber::UpdateTlcInfo::new_builder()
+            .channel_id(update_tlc_info.channel_id.into())
+            .timestamp(update_tlc_info.timestamp.pack())
+            .channel_flags(update_tlc_info.channel_flags.bits().pack())
+            .tlc_expiry_delta(update_tlc_info.tlc_expiry_delta.pack())
+            .tlc_minimum_value(update_tlc_info.tlc_minimum_value.pack())
+            .tlc_maximum_value(update_tlc_info.tlc_maximum_value.pack())
+            .tlc_fee_proportional_millionths(update_tlc_info.tlc_fee_proportional_millionths.pack())
+            .build()
+    }
+}
+
+impl From<molecule_fiber::UpdateTlcInfo> for UpdateTlcInfo {
+    fn from(update_tlc_info: molecule_fiber::UpdateTlcInfo) -> Self {
+        UpdateTlcInfo {
+            channel_id: update_tlc_info.channel_id().into(),
+            timestamp: update_tlc_info.timestamp().unpack(),
+            channel_flags: ChannelUpdateChannelFlags::from_bits_truncate(
+                update_tlc_info.channel_flags().unpack(),
+            ),
+            tlc_expiry_delta: update_tlc_info.tlc_expiry_delta().unpack(),
+            tlc_minimum_value: update_tlc_info.tlc_minimum_value().unpack(),
+            tlc_maximum_value: update_tlc_info.tlc_maximum_value().unpack(),
+            tlc_fee_proportional_millionths: update_tlc_info
+                .tlc_fee_proportional_millionths()
+                .unpack(),
+        }
+    }
+}
+
+impl From<UpdateTlcInfo> for ChannelTlcInfo {
+    fn from(update_tlc_info: UpdateTlcInfo) -> Self {
+        ChannelTlcInfo {
+            timestamp: update_tlc_info.timestamp,
+            enabled: !update_tlc_info
+                .channel_flags
+                .contains(ChannelUpdateChannelFlags::DISABLED),
+            tlc_expiry_delta: update_tlc_info.tlc_expiry_delta,
+            tlc_minimum_value: update_tlc_info.tlc_minimum_value,
+            tlc_maximum_value: update_tlc_info.tlc_maximum_value,
+            tlc_fee_proportional_millionths: update_tlc_info.tlc_fee_proportional_millionths,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
 pub struct AddTlc {
     pub channel_id: Hash256,
@@ -2074,10 +2144,10 @@ pub struct ChannelUpdate {
     // Currently only the first bit is used to indicate the direction of the channel.
     // If it is 0, it means this channel message is from node 1 (thus applies to tlcs
     // sent from node 2 to node 1). Otherwise, it is from node 2.
-    pub message_flags: u32,
+    pub message_flags: ChannelUpdateMessageFlags,
     // Currently only the first bit is used to indicate if the channel is disabled.
     // If the first bit is set, the channel is disabled.
-    pub channel_flags: u32,
+    pub channel_flags: ChannelUpdateChannelFlags,
     pub tlc_expiry_delta: u64,
     pub tlc_minimum_value: u128,
     pub tlc_fee_proportional_millionths: u128,
@@ -2087,15 +2157,15 @@ impl ChannelUpdate {
     pub fn new_unsigned(
         channel_outpoint: OutPoint,
         timestamp: u64,
-        message_flags: u32,
-        channel_flags: u32,
+        message_flags: ChannelUpdateMessageFlags,
+        channel_flags: ChannelUpdateChannelFlags,
         tlc_expiry_delta: u64,
         tlc_minimum_value: u128,
         tlc_fee_proportional_millionths: u128,
     ) -> Self {
         // To avoid having the same timestamp for both channel updates, we will use an even
         // timestamp number for node1 and an odd timestamp number for node2.
-        let timestamp = if message_flags & MESSAGE_OF_NODE2_FLAG == MESSAGE_OF_NODE2_FLAG {
+        let timestamp = if message_flags.contains(ChannelUpdateMessageFlags::UPDATE_OF_NODE2) {
             timestamp | 1u64
         } else {
             timestamp & !1u64
@@ -2133,11 +2203,13 @@ impl ChannelUpdate {
     }
 
     pub fn is_update_of_node_2(&self) -> bool {
-        self.message_flags & MESSAGE_OF_NODE2_FLAG == MESSAGE_OF_NODE2_FLAG
+        self.message_flags
+            .contains(ChannelUpdateMessageFlags::UPDATE_OF_NODE2)
     }
 
     pub fn is_disabled(&self) -> bool {
-        self.channel_flags & CHANNEL_DISABLED_FLAG == CHANNEL_DISABLED_FLAG
+        self.channel_flags
+            .contains(ChannelUpdateChannelFlags::DISABLED)
     }
 
     pub fn cursor(&self) -> Cursor {
@@ -2154,8 +2226,8 @@ impl From<ChannelUpdate> for molecule_fiber::ChannelUpdate {
             .chain_hash(channel_update.chain_hash.into())
             .channel_outpoint(channel_update.channel_outpoint)
             .timestamp(channel_update.timestamp.pack())
-            .message_flags(channel_update.message_flags.pack())
-            .channel_flags(channel_update.channel_flags.pack())
+            .message_flags(channel_update.message_flags.bits().pack())
+            .channel_flags(channel_update.channel_flags.bits().pack())
             .tlc_expiry_delta(channel_update.tlc_expiry_delta.pack())
             .tlc_minimum_value(channel_update.tlc_minimum_value.pack())
             .tlc_fee_proportional_millionths(channel_update.tlc_fee_proportional_millionths.pack());
@@ -2179,8 +2251,12 @@ impl TryFrom<molecule_fiber::ChannelUpdate> for ChannelUpdate {
             chain_hash: channel_update.chain_hash().into(),
             channel_outpoint: channel_update.channel_outpoint(),
             timestamp: channel_update.timestamp().unpack(),
-            message_flags: channel_update.message_flags().unpack(),
-            channel_flags: channel_update.channel_flags().unpack(),
+            message_flags: ChannelUpdateMessageFlags::from_bits_truncate(
+                channel_update.message_flags().unpack(),
+            ),
+            channel_flags: ChannelUpdateChannelFlags::from_bits_truncate(
+                channel_update.channel_flags().unpack(),
+            ),
             tlc_expiry_delta: channel_update.tlc_expiry_delta().unpack(),
             tlc_minimum_value: channel_update.tlc_minimum_value().unpack(),
             tlc_fee_proportional_millionths: channel_update
@@ -2291,6 +2367,7 @@ pub enum FiberChannelMessage {
     TxAckRBF(TxAckRBF),
     Shutdown(Shutdown),
     ClosingSigned(ClosingSigned),
+    UpdateTlcInfo(UpdateTlcInfo),
     AddTlc(AddTlc),
     RevokeAndAck(RevokeAndAck),
     RemoveTlc(RemoveTlc),
@@ -2314,6 +2391,7 @@ impl FiberChannelMessage {
             FiberChannelMessage::TxAckRBF(tx_ack_rbf) => tx_ack_rbf.channel_id,
             FiberChannelMessage::Shutdown(shutdown) => shutdown.channel_id,
             FiberChannelMessage::ClosingSigned(closing_signed) => closing_signed.channel_id,
+            FiberChannelMessage::UpdateTlcInfo(update_tlc_info) => update_tlc_info.channel_id,
             FiberChannelMessage::AddTlc(add_tlc) => add_tlc.channel_id,
             FiberChannelMessage::RevokeAndAck(revoke_and_ack) => revoke_and_ack.channel_id,
             FiberChannelMessage::RemoveTlc(remove_tlc) => remove_tlc.channel_id,
@@ -3313,6 +3391,9 @@ impl From<FiberMessage> for molecule_fiber::FiberMessageUnion {
                 FiberChannelMessage::ClosingSigned(closing_signed) => {
                     molecule_fiber::FiberMessageUnion::ClosingSigned(closing_signed.into())
                 }
+                FiberChannelMessage::UpdateTlcInfo(update_tlc_info) => {
+                    molecule_fiber::FiberMessageUnion::UpdateTlcInfo(update_tlc_info.into())
+                }
                 FiberChannelMessage::AddTlc(add_tlc) => {
                     molecule_fiber::FiberMessageUnion::AddTlc(add_tlc.into())
                 }
@@ -3400,6 +3481,11 @@ impl TryFrom<molecule_fiber::FiberMessageUnion> for FiberMessage {
                     closing_signed.try_into()?,
                 ))
             }
+            molecule_fiber::FiberMessageUnion::UpdateTlcInfo(update_tlc_info) => {
+                FiberMessage::ChannelNormalOperation(FiberChannelMessage::UpdateTlcInfo(
+                    update_tlc_info.into(),
+                ))
+            }
             molecule_fiber::FiberMessageUnion::AddTlc(add_tlc) => {
                 FiberMessage::ChannelNormalOperation(FiberChannelMessage::AddTlc(
                     add_tlc.try_into()?,
diff --git a/src/store/tests/store.rs b/src/store/tests/store.rs
index b6c6d7926..86d81ab78 100644
--- a/src/store/tests/store.rs
+++ b/src/store/tests/store.rs
@@ -172,7 +172,7 @@ fn test_store_save_channel_update() {
     let path = TempDir::new("test-gossip-store");
     let store = Store::new(path).expect("created store failed");
 
-    let flags_for_update_of_node1 = 0;
+    let flags_for_update_of_node1 = ChannelUpdateMessageFlags::UPDATE_OF_NODE1;
     let channel_update_of_node1 = ChannelUpdate::new_unsigned(
         OutPoint::new_builder()
             .tx_hash(gen_rand_sha256_hash().into())
@@ -180,7 +180,7 @@ fn test_store_save_channel_update() {
             .build(),
         now_timestamp_as_millis_u64(),
         flags_for_update_of_node1,
-        0,
+        ChannelUpdateChannelFlags::empty(),
         0,
         0,
         0,
@@ -194,7 +194,7 @@ fn test_store_save_channel_update() {
     assert_eq!(store.get_latest_channel_update(&out_point, false), None);
 
     let mut channel_update_of_node2 = channel_update_of_node1.clone();
-    let flags_for_update_of_node2 = 1;
+    let flags_for_update_of_node2 = ChannelUpdateMessageFlags::UPDATE_OF_NODE2;
     channel_update_of_node2.message_flags = flags_for_update_of_node2;
     // Note that per discussion in Notion, we don't handle the rare case of two channel updates having the same timestamp.
     // In the current implementation, channel update from one side with the same timestamp will not overwrite the existing one
@@ -313,10 +313,6 @@ fn test_channel_actor_state_store() {
     let state = ChannelActorState {
         state: ChannelState::NegotiatingFunding(NegotiatingFundingFlags::THEIR_INIT_SENT),
         public_channel_info: Some(PublicChannelInfo {
-            enabled: false,
-            tlc_fee_proportional_millionths: 123,
-            tlc_expiry_delta: 3,
-            tlc_min_value: 10,
             local_channel_announcement_signature: Some((
                 mock_ecdsa_signature(),
                 MaybeScalar::two(),
@@ -329,6 +325,15 @@ fn test_channel_actor_state_store() {
             channel_announcement: None,
             channel_update: None,
         }),
+        local_tlc_info: ChannelTlcInfo {
+            enabled: false,
+            timestamp: 0,
+            tlc_fee_proportional_millionths: 123,
+            tlc_expiry_delta: 3,
+            tlc_minimum_value: 10,
+            tlc_maximum_value: 0,
+        },
+        remote_tlc_info: None,
         local_pubkey: gen_rand_fiber_public_key(),
         remote_pubkey: gen_rand_fiber_public_key(),
         funding_tx: Some(Transaction::default()),
@@ -383,15 +388,7 @@ fn test_channel_actor_state_store() {
 
     let get_state = store.get_channel_actor_state(&state.id);
     assert!(get_state.is_some());
-    assert_eq!(
-        get_state
-            .unwrap()
-            .public_channel_info
-            .as_ref()
-            .unwrap()
-            .enabled,
-        false
-    );
+    assert_eq!(get_state.unwrap().is_tlc_forwarding_enabled(), false);
 
     let remote_peer_id = state.get_remote_peer_id();
     assert_eq!(
diff --git a/src/tests/mod.rs b/src/tests/mod.rs
index 7f2f760d9..d286fb372 100644
--- a/src/tests/mod.rs
+++ b/src/tests/mod.rs
@@ -6,8 +6,9 @@ use ckb_types::{packed::OutPoint, prelude::Pack};
 use secp256k1::{Keypair, PublicKey, Secp256k1, SecretKey, XOnlyPublicKey};
 
 use crate::ckb::contracts::{get_cell_deps_by_contracts, get_script_by_contract, Contract};
-use crate::fiber::channel::{MESSAGE_OF_NODE1_FLAG, MESSAGE_OF_NODE2_FLAG};
-use crate::fiber::types::{ChannelUpdate, EcdsaSignature};
+use crate::fiber::types::{
+    ChannelUpdate, ChannelUpdateChannelFlags, ChannelUpdateMessageFlags, EcdsaSignature,
+};
 use crate::{
     fiber::{
         config::AnnouncedNodeName,
@@ -131,7 +132,7 @@ impl ChannelTestContext {
 
     pub fn create_channel_update_of_node1(
         &self,
-        channel_flags: u32,
+        channel_flags: ChannelUpdateChannelFlags,
         tlc_expiry_delta: u64,
         tlc_minimum_value: u128,
         tlc_fee_proportional_millionths: u128,
@@ -139,7 +140,7 @@ impl ChannelTestContext {
         let mut unsigned_channel_update = ChannelUpdate::new_unsigned(
             self.channel_announcement.channel_outpoint.clone(),
             now_timestamp_as_millis_u64(),
-            MESSAGE_OF_NODE1_FLAG,
+            ChannelUpdateMessageFlags::UPDATE_OF_NODE1,
             channel_flags,
             tlc_expiry_delta,
             tlc_minimum_value,
@@ -153,7 +154,7 @@ impl ChannelTestContext {
 
     pub fn create_channel_update_of_node2(
         &self,
-        channel_flags: u32,
+        channel_flags: ChannelUpdateChannelFlags,
         tlc_expiry_delta: u64,
         tlc_minimum_value: u128,
         tlc_fee_proportional_millionths: u128,
@@ -161,7 +162,7 @@ impl ChannelTestContext {
         let mut unsigned_channel_update = ChannelUpdate::new_unsigned(
             self.channel_announcement.channel_outpoint.clone(),
             now_timestamp_as_millis_u64(),
-            MESSAGE_OF_NODE2_FLAG,
+            ChannelUpdateMessageFlags::UPDATE_OF_NODE2,
             channel_flags,
             tlc_expiry_delta,
             tlc_minimum_value,