Add SpliceConfig to NodeConfig

Introduce SpliceConfig with two knobs (enabled, poll_interval) and
thread it through NodeConfig and the daemon TOML loader. No
behaviour change yet; the splice manager that consumes this config
lands in a later commit.

Defaults are enabled=true and poll_interval=30s. 30s balances wasted
ticks against post-reopen responsiveness; tests will override to 1s.
There is deliberately no fee or threshold knob: the live ldk-node
estimate covers fees and ldk-node itself enforces the dust gate, so
extra configuration would just be second-guessing the wallet.

The TOML schema uses poll_interval_secs (u64) rather than a
humantime string to avoid pulling in another dependency for one
field. The [splice] section is optional; missing or partial sections
fall back to SpliceConfig::default(), so existing configs keep
loading.

SpliceConfig lives in the lib (mdk::node) rather than the daemon
crate because the splice manager itself will live in the lib too.
The daemon imports it from there.

Author: amackillop

src/daemon/config.rs

@@ -2,18 +2,22 @@ use std::io;
 use std::net::SocketAddr;
 use std::path::PathBuf;
 use std::str::FromStr;
+use std::time::Duration;
 
 use ldk_node::bitcoin::Network;
 use ldk_node::lightning::ln::msgs::SocketAddress;
 use ldk_node::lightning::routing::gossip::NodeAlias;
 use log::LevelFilter;
 use serde::Deserialize;
 
+use mdk::node::SpliceConfig;
+
 #[derive(Deserialize)]
 struct TomlConfig {
     node: Option<NodeSection>,
     storage: Option<StorageSection>,
     log: Option<LogSection>,
+    splice: Option<SpliceSection>,
 }
 
 #[derive(Deserialize)]
@@ -43,6 +47,12 @@ struct LogSection {
     file: Option<String>,
 }
 
+#[derive(Deserialize)]
+struct SpliceSection {
+    enabled: Option<bool>,
+    poll_interval_secs: Option<u64>,
+}
+
 pub struct MdkConfig {
     pub network: Network,
     pub listening_addrs: Option<Vec<SocketAddress>>,
@@ -52,6 +62,7 @@ pub struct MdkConfig {
     pub storage_dir_path: Option<String>,
     pub log_level: LevelFilter,
     pub pathfinding_scores_source_url: Option<String>,
+    pub splice: SpliceConfig,
 }
 
 pub fn load_config(path: &str) -> io::Result<MdkConfig> {
@@ -109,6 +120,20 @@ pub fn load_config(path: &str) -> io::Result<MdkConfig> {
         None => LevelFilter::Debug,
     };
 
+    let splice = match toml.splice {
+        Some(s) => {
+            let defaults = SpliceConfig::default();
+            SpliceConfig {
+                enabled: s.enabled.unwrap_or(defaults.enabled),
+                poll_interval: s
+                    .poll_interval_secs
+                    .map(Duration::from_secs)
+                    .unwrap_or(defaults.poll_interval),
+            }
+        }
+        None => SpliceConfig::default(),
+    };
+
     Ok(MdkConfig {
         network,
         listening_addrs,
@@ -118,6 +143,7 @@ pub fn load_config(path: &str) -> io::Result<MdkConfig> {
         storage_dir_path,
         log_level,
         pathfinding_scores_source_url: node.pathfinding_scores_source_url,
+        splice,
     })
 }
 

src/main.rs

@@ -131,6 +131,7 @@ fn main() {
         pathfinding_scores_source_url: config_file.pathfinding_scores_source_url,
         mnemonic: mnemonic_phrase,
         infra,
+        splice: config_file.splice,
     };
 
     // Separate HTTP client for daemon concerns (webhooks, expiry monitor).

src/mdk/node.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 use std::net::ToSocketAddrs;
 use std::str::FromStr;
 use std::sync::Arc;
+use std::time::Duration;
 
 use ldk_node::bip39::Mnemonic;
 use ldk_node::bitcoin::hashes::sha256;
@@ -26,6 +27,25 @@ pub struct NodeConfig {
     pub pathfinding_scores_source_url: Option<String>,
     pub mnemonic: String,
     pub infra: NetworkInfra,
+    pub splice: SpliceConfig,
+}
+
+/// Configuration for the auto-splice manager. The manager wakes up
+/// every `poll_interval`, reads the spendable on-chain balance, and
+/// splices it into an existing LSP channel when one is available.
+#[derive(Debug, Clone)]
+pub struct SpliceConfig {
+    pub enabled: bool,
+    pub poll_interval: Duration,
+}
+
+impl Default for SpliceConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            poll_interval: Duration::from_secs(30),
+        }
+    }
 }
 
 pub fn build_node(