Add MdkClient::splice_in wrapper

Wrap Node::splice_in with local validation (channel exists, channel
is usable, amount > 0) and a typed SpliceError ADT. Cache the
parsed LSP PublicKey on MdkClient so the wrapper and the upcoming
splice manager do not repeat the parse on every call.

The error mapping is the meaningful part. ldk-node's NodeError
exposes a single ChannelSplicingFailed variant for nearly every
splice failure (peer rejected, channel not yet ready, coin
selection failed under fee pressure) and InsufficientFunds for the
broad spendable-balance check. The splice manager needs to react
differently to "no funds, retry next tick" vs "something is
genuinely wrong", so the wrapper exposes the two cases as
SpliceError::InsufficientFunds and SpliceError::Rejected.

The mapping lives in a free helper (map_splice_error) rather than
a From impl. NodeError::InsufficientFunds is also produced by
open_channel and on-chain wallet paths, so a blanket From<NodeError>
for SpliceError would be wrong outside splice context. A free
function keeps the conversion's narrow scope obvious by name and
location, and avoids adding a discoverable trait impl that future
code might mistakenly use elsewhere.

ldk-node does not expose a way to distinguish the fee-too-high
coin-selection path from other ChannelSplicingFailed cases (the
detail only appears in a log line). The splice manager will treat
any Rejected as a retry candidate anyway, so we accept the lossy
mapping rather than parsing log output. Anything other than
InsufficientFunds collapses into Rejected.

ChannelNotUsable is a third, locally-detected variant. It could
have been folded into Rejected and left for ldk-node to surface,
but catching it before the network round-trip is cheaper and gives
the splice manager a clear signal that the channel was filtered
out by our own pre-check, not by the peer.

The daemon HTTP error mapper folds all SpliceError cases into
Internal for now. A future POST /splicein endpoint may want finer
status codes; the wrapper is only consumed internally by the
splice manager today, so that refinement is deferred.

Author: amackillop

src/daemon/api/error.rs

@@ -21,6 +21,7 @@ impl From<MdkError> for AppError {
             MdkError::Node(msg) => AppError::Internal(msg),
             MdkError::Platform { message, .. } => AppError::Internal(message),
             MdkError::Network(msg) => AppError::Internal(msg),
+            MdkError::Splice(e) => AppError::Internal(e.to_string()),
         }
     }
 }

src/mdk/client.rs

@@ -1,18 +1,20 @@
+use std::str::FromStr;
 use std::sync::Arc;
 
 use chrono::{DateTime, SecondsFormat};
 use ldk_node::bitcoin::hashes::sha256;
 use ldk_node::bitcoin::hashes::Hash as _;
+use ldk_node::bitcoin::secp256k1::PublicKey;
 use ldk_node::lightning::ln::channelmanager::PaymentId;
 use ldk_node::lightning_invoice::{Bolt11Invoice, Bolt11InvoiceDescription, Description, Sha256};
-use ldk_node::{Event, Node};
+use ldk_node::{Event, Node, NodeError, UserChannelId};
 use log::{error, info, warn};
 use reqwest::{Client, Proxy};
 use tokio::runtime::Handle;
 use tokio::sync::broadcast;
 use tokio_util::sync::CancellationToken;
 
-use crate::mdk::error::MdkError;
+use crate::mdk::error::{MdkError, SpliceError};
 use crate::mdk::mdk_api::client::MdkApiClient;
 use crate::mdk::mdk_api::types::{
     CheckoutCustomer, CreateCheckoutRequest, PaymentEntry, PaymentReceivedRequest,
@@ -32,6 +34,7 @@ pub type EventHandler = Arc<dyn Fn(MdkEvent) + Send + Sync>;
 pub struct MdkClient {
     node: Arc<Node>,
     api: Arc<MdkApiClient>,
+    lsp_pubkey: PublicKey,
     event_tx: broadcast::Sender<MdkEvent>,
     event_handler: Option<EventHandler>,
     shutdown: CancellationToken,
@@ -69,6 +72,8 @@ impl MdkClient {
 
         let api_base_url = config.infra.mdk_api_base_url.clone();
         let socks_proxy = config.socks_proxy.clone();
+        let lsp_pubkey = PublicKey::from_str(&config.infra.lsp_node_id)
+            .map_err(|e| MdkError::InvalidInput(format!("bad lsp_node_id: {e}")))?;
 
         let node = build_node(config, handle.clone())?;
         let http_client = build_http_client(socks_proxy.as_deref())?;
@@ -82,6 +87,7 @@ impl MdkClient {
         Ok(Self {
             node,
             api,
+            lsp_pubkey,
             event_tx,
             event_handler,
             shutdown: CancellationToken::new(),
@@ -115,6 +121,50 @@ impl MdkClient {
         Arc::clone(&self.node)
     }
 
+    pub fn lsp_pubkey(&self) -> PublicKey {
+        self.lsp_pubkey
+    }
+
+    /// Splice `amount_sats` of confirmed on-chain funds into the
+    /// existing channel identified by `user_channel_id`, with the
+    /// LSP as counterparty.
+    ///
+    /// Validates locally that the channel exists and is usable
+    /// before delegating to ldk-node. ldk-node's splice errors are
+    /// mapped to typed `SpliceError` variants so callers (notably
+    /// the splice manager) can pattern-match on the failure mode
+    /// without inspecting strings.
+    pub fn splice_in(
+        &self,
+        user_channel_id: UserChannelId,
+        amount_sats: u64,
+    ) -> Result<(), MdkError> {
+        if amount_sats == 0 {
+            return Err(MdkError::InvalidInput(
+                "splice amount must be greater than zero".into(),
+            ));
+        }
+
+        let channels = self.node.list_channels();
+        let channel = channels
+            .iter()
+            .find(|c| c.user_channel_id == user_channel_id)
+            .ok_or_else(|| {
+                MdkError::NotFound(format!(
+                    "channel with user_channel_id {}",
+                    user_channel_id.0
+                ))
+            })?;
+
+        if !channel.is_usable {
+            return Err(MdkError::Splice(SpliceError::ChannelNotUsable));
+        }
+
+        self.node
+            .splice_in(&user_channel_id, self.lsp_pubkey, amount_sats)
+            .map_err(map_splice_error)
+    }
+
     pub fn subscribe(&self) -> broadcast::Receiver<MdkEvent> {
         self.event_tx.subscribe()
     }
@@ -403,3 +453,17 @@ fn format_payment_id(id: &Option<PaymentId>) -> String {
         None => "unknown".into(),
     }
 }
+
+/// Map an ldk-node error returned from a splice call into a typed
+/// `MdkError::Splice`. Kept as a free helper (rather than a
+/// `From<NodeError>` impl) because `NodeError::InsufficientFunds`
+/// is also produced by `open_channel` and on-chain wallet paths,
+/// where mapping it to a splice variant would be wrong. Anything
+/// other than `InsufficientFunds` collapses to `Rejected` — the
+/// splice manager treats the catch-all bucket uniformly.
+fn map_splice_error(e: NodeError) -> MdkError {
+    match e {
+        NodeError::InsufficientFunds => MdkError::Splice(SpliceError::InsufficientFunds),
+        _ => MdkError::Splice(SpliceError::Rejected),
+    }
+}

src/mdk/error.rs

@@ -13,6 +13,36 @@ pub enum MdkError {
     },
     Network(String),
     NotFound(String),
+    Splice(SpliceError),
+}
+
+/// Typed splice failure modes. Modeled as an ADT so the splice
+/// manager can decide what to do (skip vs. emit failure event)
+/// without inspecting log strings.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SpliceError {
+    /// The target channel exists but is not currently usable
+    /// (mid-splice, peer disconnected, mid-monitor-update). The
+    /// splice manager should skip this tick and try again.
+    ChannelNotUsable,
+    /// The on-chain wallet does not have enough confirmed funds
+    /// for the requested splice amount. Retried next tick.
+    InsufficientFunds,
+    /// ldk-node refused the splice (coin selection failed under
+    /// fee pressure, channel not yet ready, peer rejected, etc.).
+    /// ldk-node currently collapses these into one error variant;
+    /// we do too.
+    Rejected,
+}
+
+impl fmt::Display for SpliceError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            SpliceError::ChannelNotUsable => write!(f, "channel not usable"),
+            SpliceError::InsufficientFunds => write!(f, "insufficient confirmed on-chain funds"),
+            SpliceError::Rejected => write!(f, "splice rejected by ldk-node"),
+        }
+    }
 }
 
 impl fmt::Display for MdkError {
@@ -27,6 +57,7 @@ impl fmt::Display for MdkError {
             } => write!(f, "platform API error ({status}): [{code}] {message}"),
             MdkError::Network(msg) => write!(f, "network error: {msg}"),
             MdkError::NotFound(msg) => write!(f, "not found: {msg}"),
+            MdkError::Splice(e) => write!(f, "splice error: {e}"),
         }
     }
 }