fix: use u32::MAX for network graph reset to avoid LDK early return

LDK's remove_stale_channels_and_tracking_with_time() returns immediately
if current_time > u32::MAX. Passing u64::MAX meant the graph was never
actually cleared. Use u32::MAX instead so all channels appear stale.

Also includes Swift bindings for listClosedChannels and ClosedChannelDetails.

Author: kaloudis

bindings/swift/Sources/LDKNode/LDKNode.swift

@@ -2779,6 +2779,8 @@ public protocol NodeProtocol : AnyObject {
 
     func listChannels()  -> [ChannelDetails]
 
+    func listClosedChannels()  -> [ClosedChannelDetails]
+    
     func listPayments()  -> [PaymentDetails]
 
     func listPeers()  -> [PeerDetails]
@@ -2977,6 +2979,13 @@ open func listChannels() -> [ChannelDetails] {
 })
 }
 
+open func listClosedChannels() -> [ClosedChannelDetails] {
+    return try!  FfiConverterSequenceTypeClosedChannelDetails.lift(try! rustCall() {
+    uniffi_ldk_node_fn_method_node_list_closed_channels(self.uniffiClonePointer(),$0
+    )
+})
+}
+    
 open func listPayments() -> [PaymentDetails] {
     return try!  FfiConverterSequenceTypePaymentDetails.lift(try! rustCall() {
     uniffi_ldk_node_fn_method_node_list_payments(self.uniffiClonePointer(),$0
@@ -5371,6 +5380,120 @@ public func FfiConverterTypeChannelUpdateInfo_lower(_ value: ChannelUpdateInfo)
 }
 
 
+public struct ClosedChannelDetails {
+    public var channelId: ChannelId
+    public var userChannelId: UserChannelId
+    public var counterpartyNodeId: PublicKey?
+    public var fundingTxo: OutPoint?
+    public var channelCapacitySats: UInt64?
+    public var lastLocalBalanceMsat: UInt64?
+    public var closureReason: ClosureReason?
+    public var closedAtTimestamp: UInt64
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(channelId: ChannelId, userChannelId: UserChannelId, counterpartyNodeId: PublicKey?, fundingTxo: OutPoint?, channelCapacitySats: UInt64?, lastLocalBalanceMsat: UInt64?, closureReason: ClosureReason?, closedAtTimestamp: UInt64) {
+        self.channelId = channelId
+        self.userChannelId = userChannelId
+        self.counterpartyNodeId = counterpartyNodeId
+        self.fundingTxo = fundingTxo
+        self.channelCapacitySats = channelCapacitySats
+        self.lastLocalBalanceMsat = lastLocalBalanceMsat
+        self.closureReason = closureReason
+        self.closedAtTimestamp = closedAtTimestamp
+    }
+}
+
+
+
+extension ClosedChannelDetails: Equatable, Hashable {
+    public static func ==(lhs: ClosedChannelDetails, rhs: ClosedChannelDetails) -> Bool {
+        if lhs.channelId != rhs.channelId {
+            return false
+        }
+        if lhs.userChannelId != rhs.userChannelId {
+            return false
+        }
+        if lhs.counterpartyNodeId != rhs.counterpartyNodeId {
+            return false
+        }
+        if lhs.fundingTxo != rhs.fundingTxo {
+            return false
+        }
+        if lhs.channelCapacitySats != rhs.channelCapacitySats {
+            return false
+        }
+        if lhs.lastLocalBalanceMsat != rhs.lastLocalBalanceMsat {
+            return false
+        }
+        if lhs.closureReason != rhs.closureReason {
+            return false
+        }
+        if lhs.closedAtTimestamp != rhs.closedAtTimestamp {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(channelId)
+        hasher.combine(userChannelId)
+        hasher.combine(counterpartyNodeId)
+        hasher.combine(fundingTxo)
+        hasher.combine(channelCapacitySats)
+        hasher.combine(lastLocalBalanceMsat)
+        hasher.combine(closureReason)
+        hasher.combine(closedAtTimestamp)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeClosedChannelDetails: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ClosedChannelDetails {
+        return
+            try ClosedChannelDetails(
+                channelId: FfiConverterTypeChannelId.read(from: &buf), 
+                userChannelId: FfiConverterTypeUserChannelId.read(from: &buf), 
+                counterpartyNodeId: FfiConverterOptionTypePublicKey.read(from: &buf), 
+                fundingTxo: FfiConverterOptionTypeOutPoint.read(from: &buf), 
+                channelCapacitySats: FfiConverterOptionUInt64.read(from: &buf), 
+                lastLocalBalanceMsat: FfiConverterOptionUInt64.read(from: &buf), 
+                closureReason: FfiConverterOptionTypeClosureReason.read(from: &buf), 
+                closedAtTimestamp: FfiConverterUInt64.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: ClosedChannelDetails, into buf: inout [UInt8]) {
+        FfiConverterTypeChannelId.write(value.channelId, into: &buf)
+        FfiConverterTypeUserChannelId.write(value.userChannelId, into: &buf)
+        FfiConverterOptionTypePublicKey.write(value.counterpartyNodeId, into: &buf)
+        FfiConverterOptionTypeOutPoint.write(value.fundingTxo, into: &buf)
+        FfiConverterOptionUInt64.write(value.channelCapacitySats, into: &buf)
+        FfiConverterOptionUInt64.write(value.lastLocalBalanceMsat, into: &buf)
+        FfiConverterOptionTypeClosureReason.write(value.closureReason, into: &buf)
+        FfiConverterUInt64.write(value.closedAtTimestamp, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeClosedChannelDetails_lift(_ buf: RustBuffer) throws -> ClosedChannelDetails {
+    return try FfiConverterTypeClosedChannelDetails.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeClosedChannelDetails_lower(_ value: ClosedChannelDetails) -> RustBuffer {
+    return FfiConverterTypeClosedChannelDetails.lower(value)
+}
+
+
 public struct Config {
     public var storageDirPath: String
     public var network: Network
@@ -11276,6 +11399,31 @@ fileprivate struct FfiConverterSequenceTypeChannelDetails: FfiConverterRustBuffe
     }
 }
 
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeClosedChannelDetails: FfiConverterRustBuffer {
+    typealias SwiftType = [ClosedChannelDetails]
+
+    public static func write(_ value: [ClosedChannelDetails], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeClosedChannelDetails.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ClosedChannelDetails] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [ClosedChannelDetails]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeClosedChannelDetails.read(from: &buf))
+        }
+        return seq
+    }
+}
+
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
@@ -12936,6 +13084,9 @@ private var initializationResult: InitializationResult = {
     if (uniffi_ldk_node_checksum_method_node_list_channels() != 7954) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_ldk_node_checksum_method_node_list_closed_channels() != 18081) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_ldk_node_checksum_method_node_list_payments() != 35002) {
         return InitializationResult.apiChecksumMismatch
     }

src/lib.rs

@@ -1784,8 +1784,10 @@ impl Node {
 			})?;
 		}
 
-		// Clear the in-memory graph by marking all channels as stale
-		self.network_graph.remove_stale_channels_and_tracking_with_time(u64::MAX);
+		// Clear the in-memory graph by marking all channels as stale.
+		// Note: LDK's implementation returns early if current_time > u32::MAX,
+		// so we pass u32::MAX to ensure all channels appear stale and get removed.
+		self.network_graph.remove_stale_channels_and_tracking_with_time(u32::MAX as u64);
 
 		Ok(())
 	}