feat(cch): implement order persistence and housekeeping (#1045)

* feat(cch): store orders in rocksdb

* feat(cch): resume order processing from store

Added `post_start` method to `CchActor` to load orders from store on startup and starting the state machines for active orderse.

* cch order housekeeping

Introduce a dedicated scheduler actor to handle time-based expiry of
active CCH orders and delayed pruning of final orders (after 21 days).
This ensures expired orders are marked as Failed and old final orders
are cleaned up.

- The CchActor now spawns a CchOrderSchedulerActor at startup and delegates scheduling responsibilities to it.
- Orders are scheduled for expiry when created or resumed, and for pruning once they reach a final state.
- The scheduler uses a binary heap to manage jobs and dynamically schedules the next processing tick based on the earliest due job.
- Added necessary store trait method `delete_cch_order`
- Updated state machine to prevent invalid transitions to Failed from Succeeded.

Author: doitian

crates/fiber-bin/src/main.rs

@@ -332,13 +332,14 @@ pub async fn main() -> Result<(), ExitMessage> {
                 .map_err(|err| ExitMessage(format!("failed to read secret key: {}", err)))?;
             match Actor::spawn_linked(
                 Some("cch actor".to_string()),
-                CchActor,
+                CchActor::default(),
                 CchArgs {
                     config: cch_config,
                     tracker: new_tokio_task_tracker(),
                     token: new_tokio_cancellation_token(),
                     network_actor: network_actor.clone(),
                     node_keypair,
+                    store: store.clone(),
                 },
                 root_actor.get_cell(),
             )

crates/fiber-lib/src/cch/actions/mod.rs

@@ -11,7 +11,7 @@ use track_outgoing_payment::TrackOutgoingPaymentDispatcher;
 use anyhow::Result;
 use ractor::ActorRef;
 
-use crate::cch::{actor::CchState, CchMessage, CchOrder, CchOrderStatus};
+use crate::cch::{actor::CchState, CchMessage, CchOrder, CchOrderStatus, CchOrderStore};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum CchOrderAction {
@@ -29,8 +29,8 @@ pub trait ActionExecutor: Send + Sync {
 pub struct ActionDispatcher;
 
 impl ActionDispatcher {
-    fn dispatch(
-        state: &mut CchState,
+    fn dispatch<S: CchOrderStore>(
+        state: &CchState<S>,
         cch_actor_ref: &ActorRef<CchMessage>,
         order: &CchOrder,
         action: CchOrderAction,
@@ -51,6 +51,21 @@ impl ActionDispatcher {
         }
     }
 
+    /// The actions to be taken when the state machine is started for the order.
+    pub fn on_starting(order: &CchOrder) -> Vec<CchOrderAction> {
+        let mut actions = Self::on_entering(order);
+        match order.status {
+            CchOrderStatus::IncomingAccepted
+            | CchOrderStatus::OutgoingInFlight
+            | CchOrderStatus::OutgoingSucceeded => {
+                // Ensure start incoming invoice tracking.
+                actions.push(CchOrderAction::TrackIncomingInvoice);
+            }
+            _ => {}
+        }
+        actions
+    }
+
     /// The actions to be taken when the order enters a new status.
     pub fn on_entering(order: &CchOrder) -> Vec<CchOrderAction> {
         match order.status {
@@ -69,8 +84,8 @@ impl ActionDispatcher {
     /// Execute an action.
     ///
     /// Executor cannot modify the order directly, but can send events to the actor.
-    pub async fn execute(
-        state: &mut CchState,
+    pub async fn execute<S: CchOrderStore>(
+        state: &CchState<S>,
         cch_actor_ref: &ActorRef<CchMessage>,
         order: &CchOrder,
         action: CchOrderAction,

crates/fiber-lib/src/cch/actions/send_outgoing_payment.rs

@@ -11,7 +11,7 @@ use crate::{
         },
         actor::CchState,
         trackers::{map_lnd_payment_changed_event, CchTrackingEvent, LndConnectionInfo},
-        CchMessage, CchOrder, CchOrderStatus,
+        CchMessage, CchOrder, CchOrderStatus, CchOrderStore,
     },
     fiber::{
         payment::{PaymentStatus, SendPaymentCommand},
@@ -162,8 +162,8 @@ impl SendOutgoingPaymentDispatcher {
         order.status == CchOrderStatus::IncomingAccepted
     }
 
-    pub fn dispatch(
-        state: &mut CchState,
+    pub fn dispatch<S: CchOrderStore>(
+        state: &CchState<S>,
         cch_actor_ref: &ActorRef<CchMessage>,
         order: &CchOrder,
     ) -> Option<Box<dyn ActionExecutor>> {

crates/fiber-lib/src/cch/actions/settle_incoming_invoice.rs

@@ -10,7 +10,7 @@ use crate::{
         },
         actor::CchState,
         trackers::{CchTrackingEvent, LndConnectionInfo},
-        CchMessage, CchOrder, CchOrderStatus,
+        CchMessage, CchOrder, CchOrderStatus, CchOrderStore,
     },
     fiber::{types::Hash256, NetworkActorCommand, NetworkActorMessage, ASSUME_NETWORK_ACTOR_ALIVE},
     invoice::{CkbInvoiceStatus, SettleInvoiceError},
@@ -125,8 +125,8 @@ impl SettleIncomingInvoiceDispatcher {
         order.status == CchOrderStatus::OutgoingSucceeded
     }
 
-    pub fn dispatch(
-        state: &mut CchState,
+    pub fn dispatch<S: CchOrderStore>(
+        state: &CchState<S>,
         cch_actor_ref: &ActorRef<CchMessage>,
         order: &CchOrder,
     ) -> Option<Box<dyn ActionExecutor>> {

crates/fiber-lib/src/cch/actions/track_incoming_invoice.rs

@@ -8,7 +8,7 @@ use crate::{
         },
         actor::CchState,
         trackers::LndTrackerMessage,
-        CchMessage, CchOrder,
+        CchMessage, CchOrder, CchOrderStore,
     },
     fiber::types::Hash256,
 };
@@ -36,8 +36,8 @@ impl TrackIncomingInvoiceDispatcher {
         !order.is_final()
     }
 
-    pub fn dispatch(
-        state: &mut CchState,
+    pub fn dispatch<S: CchOrderStore>(
+        state: &CchState<S>,
         _cch_actor_ref: &ActorRef<CchMessage>,
         order: &CchOrder,
     ) -> Option<Box<dyn ActionExecutor>> {

crates/fiber-lib/src/cch/actions/track_outgoing_payment.rs

@@ -1,12 +1,12 @@
 use ractor::ActorRef;
 
-use crate::cch::{actions::ActionExecutor, actor::CchState, CchMessage, CchOrder};
+use crate::cch::{actions::ActionExecutor, actor::CchState, CchMessage, CchOrder, CchOrderStore};
 
 pub struct TrackOutgoingPaymentDispatcher;
 
 impl TrackOutgoingPaymentDispatcher {
-    pub fn dispatch(
-        _state: &mut CchState,
+    pub fn dispatch<S: CchOrderStore>(
+        _state: &CchState<S>,
         _cch_actor_ref: &ActorRef<CchMessage>,
         _order: &CchOrder,
     ) -> Option<Box<dyn ActionExecutor>> {