LDK MCP Server

Instructions

Input Schema

Input Schema (JSON Schema)

Implementation Reference

• src/tools/getSwiftCode.ts:3-1667 (handler)

  The complete tool definition including the handler function 'execute' that provides Swift code examples for various LDK operations based on the input 'operation' parameter. Also includes the input schema.
  export const getSwiftCodeTool: Tool = { name: 'ldk_get_swift_code', description: 'Get Swift code examples for specific LDK operations', inputSchema: { type: 'object', properties: { operation: { type: 'string', enum: [ 'channel_manager_setup', 'peer_connection', 'event_handling', 'persistence', 'network_sync', 'fee_estimation', 'routing', 'background_tasks' ], description: 'Type of operation to get Swift code for' } }, required: ['operation'] }, execute: async (args: any): Promise<ToolResult> => { const codeExamples: Record<string, string> = { channel_manager_setup: ` // Complete ChannelManager setup in Swift using LDK import LightningDevKit class LDKManager { private var channelManager: Bindings.ChannelManager! private var channelManagerConstructor: Bindings.ChannelManagerConstructor! private var keysManager: Bindings.KeysManager! private var chainMonitor: Bindings.ChainMonitor! private var networkGraph: Bindings.NetworkGraph! private var scorer: Bindings.MultiThreadedLockableScore! private var router: Bindings.DefaultRouter! private var peerManager: Bindings.PeerManager! private var logger: Bindings.Logger! func initialize(network: Bindings.Network, seed: [UInt8]) async throws { // 1. Initialize Keys Manager let timestampSeconds = UInt64(Date().timeIntervalSince1970) let timestampNanos = UInt32(timestampSeconds * 1000 * 1000) keysManager = Bindings.KeysManager( seed: seed, startingTimeSecs: timestampSeconds, startingTimeNanos: timestampNanos ) // 2. Initialize Fee Estimator let feeEstimator = MyFeeEstimator() // 3. Initialize Logger let logger = MyLogger() // 4. Initialize Broadcaster let broadcaster = MyBroadcaster() // 5. Initialize Persister let persister = MyPersister() // 6. Initialize Filter (for light clients) let filter = MyFilter() // 7. Initialize Chain Monitor chainMonitor = Bindings.ChainMonitor( chainSource: filter, broadcaster: broadcaster, logger: logger, feeEstimator: feeEstimator, persister: persister ) // 8. Initialize Network Graph let serializedGraph = loadNetworkGraph() // Load from disk if exists if let graphBytes = serializedGraph { let readResult = Bindings.NetworkGraph.read(ser: graphBytes, arg: logger) if readResult.isOk() { networkGraph = readResult.getValue()! } else { networkGraph = Bindings.NetworkGraph(network: network, logger: logger) } } else { networkGraph = Bindings.NetworkGraph(network: network, logger: logger) } // 9. Initialize Router let decayParams = Bindings.ProbabilisticScoringDecayParameters.initWithDefault() let probabilisticScorer = Bindings.ProbabilisticScorer( decayParams: decayParams, networkGraph: networkGraph, logger: logger ) scorer = Bindings.MultiThreadedLockableScore(score: probabilisticScorer.asScore()) // 10. Initialize Channel Manager let channelMonitors = loadChannelMonitors() // Load from disk let serializedManager = loadChannelManager() // Load from disk if exists let constructorParams = Bindings.ChannelManagerConstructionParameters( config: Bindings.UserConfig.initWithDefault(), entropySource: keysManager.asEntropySource(), nodeSigner: keysManager.asNodeSigner(), signerProvider: keysManager.asSignerProvider(), feeEstimator: feeEstimator, chainMonitor: chainMonitor, txBroadcaster: broadcaster, logger: logger, router: Bindings.DefaultRouter( networkGraph: networkGraph, logger: logger, randomSeedBytes: keysManager.asEntropySource().getSecureRandomBytes(), scorer: scorer, scoreParams: Bindings.ProbabilisticScoringFeeParameters.initWithDefault() ) ) if let managerBytes = serializedManager, !managerBytes.isEmpty { // Restart - load from serialized do { channelManagerConstructor = try Bindings.ChannelManagerConstructor( channelManagerSerialized: managerBytes, channelMonitorsSerialized: channelMonitors, networkGraph: Bindings.NetworkGraphArgument.instance(networkGraph), filter: filter, params: constructorParams ) } catch { // Fresh start if loading fails channelManagerConstructor = createFreshChannelManager(params: constructorParams) } } else { // Fresh start channelManagerConstructor = createFreshChannelManager(params: constructorParams) } channelManager = channelManagerConstructor.channelManager // 11. Sync to chain tip await syncToChainTip() // 12. Start background processing channelManagerConstructor.chainSyncCompleted(persister: MyEventHandler()) } private func createFreshChannelManager(params: Bindings.ChannelManagerConstructionParameters) -> Bindings.ChannelManagerConstructor { let (blockHash, blockHeight) = getChainTip() return Bindings.ChannelManagerConstructor( network: network, currentBlockchainTipHash: blockHash, currentBlockchainTipHeight: blockHeight, netGraph: networkGraph, params: params ) } }`.trim(), peer_connection: ` // Peer connection management in Swift import LightningDevKit class PeerConnectionManager { private let peerManager: PeerManager private var connections: [String: TcpPeerHandler] = [:] init(channelManagerConstructor: ChannelManagerConstructor) { self.peerManager = channelManagerConstructor.peerManager } func connectToPeer(pubkey: String, address: String, port: UInt16) async throws { guard let pubkeyData = Data(hexString: pubkey), pubkeyData.count == 33 else { throw PeerError.invalidPubkey } // Check if already connected let connectedPeers = peerManager.getPeerNodeIds() if connectedPeers.contains(where: { $0.0 == pubkeyData.bytes }) { print("Already connected to peer") return } // Create TCP connection handler let tcpHandler = TCPPeerHandler( peerManager: peerManager, socketAddress: address, port: port ) // Initiate connection let connected = await tcpHandler.connect() guard connected else { throw PeerError.connectionFailed } // Store connection connections[pubkey] = tcpHandler // Start message processing tcpHandler.startMessageHandling() } func disconnectPeer(pubkey: String) { guard let pubkeyData = Data(hexString: pubkey), pubkeyData.count == 33 else { return } peerManager.disconnectByNodeId(nodeId: pubkeyData.bytes) connections.removeValue(forKey: pubkey) } func listConnectedPeers() -> [(pubkey: String, address: String)] { return peerManager.getPeerNodeIds().compactMap { peer in let pubkey = Data(peer.0).hexString if let connection = connections[pubkey] { return (pubkey: pubkey, address: connection.remoteAddress) } return nil } } } // TCP Connection Handler class TCPPeerHandler { private let peerManager: PeerManager private let socketAddress: String private let port: UInt16 private var connection: NWConnection? var remoteAddress: String { return "\\(socketAddress):\\(port)" } init(peerManager: PeerManager, socketAddress: String, port: UInt16) { self.peerManager = peerManager self.socketAddress = socketAddress self.port = port } func connect() async -> Bool { let host = NWEndpoint.Host(socketAddress) let port = NWEndpoint.Port(rawValue: self.port)! connection = NWConnection(host: host, port: port, using: .tcp) let connected = await withCheckedContinuation { continuation in connection?.stateUpdateHandler = { state in switch state { case .ready: continuation.resume(returning: true) case .failed(_), .cancelled: continuation.resume(returning: false) default: break } } connection?.start(queue: .global()) } return connected } func startMessageHandling() { receiveMessage() } private func receiveMessage() { connection?.receive(minimumIncompleteLength: 1, maximumLength: 65536) { data, _, isComplete, error in if let data = data, !data.isEmpty { // Process received data through peer manager let result = self.peerManager.readEvent( peerDescriptor: self.getDescriptor(), data: [UInt8](data) ) if result.isOk() { // Continue receiving self.receiveMessage() } } if isComplete || error != nil { // Connection closed self.handleDisconnection() } } } private func handleDisconnection() { // Clean up connection?.cancel() connection = nil } private func getDescriptor() -> SocketDescriptor { // Implementation of socket descriptor for this connection return MySocketDescriptor(connection: connection!) } }`.trim(), event_handling: ` // Comprehensive event handling in Swift import LightningDevKit import BitcoinDevKit class LDKEventHandler: Bindings.EventHandler { private let channelManager: Bindings.ChannelManager private let wallet: BitcoinDevKit.Wallet private let keysManager: Bindings.KeysManager init(channelManager: Bindings.ChannelManager, wallet: BitcoinDevKit.Wallet, keysManager: Bindings.KeysManager) { self.channelManager = channelManager self.wallet = wallet self.keysManager = keysManager super.init() } override func handleEvent(event: Bindings.Event) { switch event.getValueType() { case .FundingGenerationReady: handleFundingGeneration(event.getValueAsFundingGenerationReady()!) case .PaymentClaimable: handlePaymentClaimable(event.getValueAsPaymentClaimable()!) case .PaymentSent: handlePaymentSent(event.getValueAsPaymentSent()!) case .PaymentFailed: handlePaymentFailed(event.getValueAsPaymentFailed()!) case .PaymentPathSuccessful: handlePaymentPathSuccessful(event.getValueAsPaymentPathSuccessful()!) case .PaymentPathFailed: handlePaymentPathFailed(event.getValueAsPaymentPathFailed()!) case .PaymentForwarded: handlePaymentForwarded(event.getValueAsPaymentForwarded()!) case .ChannelReady: handleChannelReady(event.getValueAsChannelReady()!) case .ChannelClosed: handleChannelClosed(event.getValueAsChannelClosed()!) case .SpendableOutputs: handleSpendableOutputs(event.getValueAsSpendableOutputs()!) case .HTLCIntercepted: handleHTLCIntercepted(event.getValueAsHTLCIntercepted()!) default: print("Unhandled event type: \\(event.getValueType())") } } private func handleFundingGeneration(_ event: Bindings.Event.FundingGenerationReady) { Task { do { let outputScript = Script(rawOutputScript: event.getOutputScript()) let amount = event.getChannelValueSatoshis() // Build funding transaction let txBuilder = try TxBuilder() .addRecipient(script: outputScript, amount: amount) .feeRate(satPerVbyte: 5.0) .enableRbf() let psbt = try txBuilder.finish(wallet: wallet) let signed = try wallet.sign(psbt: psbt, signOptions: nil) let fundingTx = signed.extractTx() // Provide to channel manager channelManager.fundingTransactionGenerated( temporaryChannelId: event.getTemporaryChannelId(), counterpartyNodeId: event.getCounterpartyNodeId(), fundingTransaction: fundingTx.serialize() ) // Broadcast transaction try await broadcastTransaction(fundingTx) // Notify UI NotificationCenter.default.post( name: .channelPendingFunding, object: nil, userInfo: ["channelId": event.getTemporaryChannelId().toHex()] ) } catch { print("Funding generation failed: \\(error)") } } } private func handlePaymentClaimable(_ event: Bindings.Event.PaymentClaimable) { let paymentHash = event.getPaymentHash() let amountMsat = event.getClaimableAmountMsat() let purpose = event.getPurpose() // Claim the payment channelManager.claimFunds(paymentPreimage: event.getPaymentPreimage()) // Update UI DispatchQueue.main.async { NotificationCenter.default.post( name: .paymentReceived, object: nil, userInfo: [ "paymentHash": paymentHash.toHex(), "amountMsat": amountMsat, "description": purpose.description ?? "" ] ) } // Show notification LightningNotificationService.notifyPaymentReceived( amountMsat: amountMsat, description: purpose.description ) } private func handlePaymentSent(_ event: Bindings.Event.PaymentSent) { let paymentHash = event.getPaymentHash() let paymentPreimage = event.getPaymentPreimage() let feePaidMsat = event.getFeePaidMsat()?.getValue() ?? 0 // Update payment record PaymentStore.shared.markPaymentSucceeded( paymentHash: paymentHash.toHex(), preimage: paymentPreimage.toHex(), feeMsat: feePaidMsat ) // Update UI DispatchQueue.main.async { NotificationCenter.default.post( name: .paymentSent, object: nil, userInfo: [ "paymentHash": paymentHash.toHex(), "feeMsat": feePaidMsat ] ) } } private func handleSpendableOutputs(_ event: Bindings.Event.SpendableOutputs) { let outputs = event.getOutputs() Task { do { // Get sweep address let address = try wallet.getAddress(addressIndex: .new) let script = try Address( address: address.address.asString(), network: .testnet ).scriptPubkey().toBytes() // Build sweep transaction let result = keysManager.spendSpendableOutputs( descriptors: outputs, outputs: [], changeDestinationScript: script, feerateSatPer1000Weight: 1000, locktime: nil ) if result.isOk(), let tx = result.getValue() { // Broadcast try await broadcastTransaction(Data(tx)) print("Swept \\(outputs.count) spendable outputs") } } catch { print("Failed to sweep outputs: \\(error)") } } } } // Notification extensions extension Notification.Name { static let channelPendingFunding = Notification.Name("ldkChannelPendingFunding") static let paymentReceived = Notification.Name("ldkPaymentReceived") static let paymentSent = Notification.Name("ldkPaymentSent") static let channelReady = Notification.Name("ldkChannelReady") static let channelClosed = Notification.Name("ldkChannelClosed") }`.trim(), persistence: ` // Channel and state persistence in Swift import LightningDevKit import Foundation class LDKPersistence: Persist, Persister { private let documentsDirectory: URL private let channelMonitorDirectory: URL private let channelManagerPath: URL private let networkGraphPath: URL private let scorerPath: URL init() throws { // Setup directories documentsDirectory = FileManager.default.urls( for: .documentDirectory, in: .userDomainMask ).first! let ldkDirectory = documentsDirectory.appendingPathComponent("ldk") channelMonitorDirectory = ldkDirectory.appendingPathComponent("channel_monitors") channelManagerPath = ldkDirectory.appendingPathComponent("channel_manager.bin") networkGraphPath = ldkDirectory.appendingPathComponent("network_graph.bin") scorerPath = ldkDirectory.appendingPathComponent("scorer.bin") // Create directories try FileManager.default.createDirectory( at: channelMonitorDirectory, withIntermediateDirectories: true ) } // MARK: - Persist Protocol (for ChannelMonitor) override func persistNewChannel( channelId: OutPoint, data: ChannelMonitor, updateId: MonitorUpdateId ) -> ChannelMonitorUpdateStatus { let channelIdHex = channelId.toChannelId().toHex() let monitorPath = channelMonitorDirectory .appendingPathComponent("\\(channelIdHex).bin") do { let serialized = data.write() try Data(serialized).write(to: monitorPath) // Backup to iCloud backupToICloud(data: Data(serialized), filename: "\\(channelIdHex).bin") return .completed } catch { print("Failed to persist new channel: \\(error)") return .permanentFailure } } override func updatePersistedChannel( channelId: OutPoint, update: ChannelMonitorUpdate?, data: ChannelMonitor, updateId: MonitorUpdateId ) -> ChannelMonitorUpdateStatus { // For simplicity, we'll just persist the full monitor // In production, you might want to store updates separately return persistNewChannel( channelId: channelId, data: data, updateId: updateId ) } // MARK: - Persister Protocol (for ChannelManager) override func persistManager(channelManager: ChannelManager) -> Result_NoneIOErrorZ { do { let serialized = channelManager.write() try Data(serialized).write(to: channelManagerPath) return Result_NoneIOErrorZ.initWithOk() } catch { return Result_NoneIOErrorZ.initWithErr(e: .init()) } } override func persistGraph(networkGraph: NetworkGraph) -> Result_NoneIOErrorZ { do { let serialized = networkGraph.write() try Data(serialized).write(to: networkGraphPath) return Result_NoneIOErrorZ.initWithOk() } catch { return Result_NoneIOErrorZ.initWithErr(e: .init()) } } override func persistScorer(scorer: WriteableScore) -> Result_NoneIOErrorZ { do { let serialized = scorer.write() try Data(serialized).write(to: scorerPath) return Result_NoneIOErrorZ.initWithOk() } catch { return Result_NoneIOErrorZ.initWithErr(e: .init()) } } // MARK: - Loading Methods func loadChannelMonitors() -> [[UInt8]] { var monitors: [[UInt8]] = [] do { let files = try FileManager.default.contentsOfDirectory( at: channelMonitorDirectory, includingPropertiesForKeys: nil ) for file in files where file.pathExtension == "bin" { let data = try Data(contentsOf: file) monitors.append([UInt8](data)) } } catch { print("Failed to load channel monitors: \\(error)") } return monitors } func loadChannelManager() -> [UInt8]? { do { let data = try Data(contentsOf: channelManagerPath) return [UInt8](data) } catch { return nil } } func loadNetworkGraph() -> [UInt8]? { do { let data = try Data(contentsOf: networkGraphPath) return [UInt8](data) } catch { return nil } } func loadScorer() -> [UInt8]? { do { let data = try Data(contentsOf: scorerPath) return [UInt8](data) } catch { return nil } } // MARK: - iCloud Backup private func backupToICloud(data: Data, filename: String) { guard let containerURL = FileManager.default.url( forUbiquityContainerIdentifier: nil ) else { return } let backupDirectory = containerURL .appendingPathComponent("Documents") .appendingPathComponent("ldk_backup") do { try FileManager.default.createDirectory( at: backupDirectory, withIntermediateDirectories: true ) let backupPath = backupDirectory.appendingPathComponent(filename) try data.write(to: backupPath) } catch { print("iCloud backup failed: \\(error)") } } } // Extension for automatic persistence extension ChannelManager { func setupAutoPersistence(persister: LDKPersistence) { // Persist after every update Timer.scheduledTimer(withTimeInterval: 30, repeats: true) { _ in _ = persister.persistManager(channelManager: self) } } }`.trim(), network_sync: ` // Network synchronization in Swift import LightningDevKit class NetworkSynchronizer { private let channelManager: ChannelManager private let chainMonitor: ChainMonitor private let rapidGossipSync: RapidGossipSync? private var syncTimer: Timer? init(channelManager: ChannelManager, chainMonitor: ChainMonitor, networkGraph: NetworkGraph, logger: Logger) { self.channelManager = channelManager self.chainMonitor = chainMonitor self.rapidGossipSync = RapidGossipSync(networkGraph: networkGraph, logger: logger) } // MARK: - Chain Sync (Electrum/Esplora) func syncWithElectrum(client: ElectrumClient) async throws { // Get relevant transactions to monitor let relevantTxIds = getRelevantTransactions() // Check for reorgs let unconfirmedTxs = try await client.checkReorgs(txIds: relevantTxIds) for txid in unconfirmedTxs { channelManager.asConfirm().transactionUnconfirmed(txid: txid) chainMonitor.asConfirm().transactionUnconfirmed(txid: txid) } // Get confirmed transactions let confirmedTxs = try await client.getConfirmedTransactions( addresses: getWatchedAddresses() ) for tx in confirmedTxs { let header = try await client.getBlockHeader(height: tx.height) let txData = [(tx.position, tx.rawTx)] channelManager.asConfirm().transactionsConfirmed( header: header, txdata: txData, height: tx.height ) chainMonitor.asConfirm().transactionsConfirmed( header: header, txdata: txData, height: tx.height ) } // Update to chain tip let (tipHash, tipHeight) = try await client.getChainTip() channelManager.asConfirm().bestBlockUpdated( header: tipHash, height: tipHeight ) chainMonitor.asConfirm().bestBlockUpdated( header: tipHash, height: tipHeight ) } // MARK: - Rapid Gossip Sync func syncGossip() async { guard let rgs = rapidGossipSync else { return } let lastSync = networkGraph.getLastRapidGossipSyncTimestamp() ?? 0 let url = URL(string: "https://rapidsync.lightningdevkit.org/snapshot/\\(lastSync)")! do { let (data, _) = try await URLSession.shared.data(from: url) let timestamp = UInt64(Date().timeIntervalSince1970) let result = rgs.updateNetworkGraphNoStd( updateData: [UInt8](data), currentTimeUnix: timestamp ) if result.isOk() { print("Gossip sync successful") } } catch { print("Gossip sync failed: \\(error)") } } // MARK: - Background Sync func startBackgroundSync(interval: TimeInterval = 30) { syncTimer = Timer.scheduledTimer( withTimeInterval: interval, repeats: true ) { _ in Task { await self.performBackgroundSync() } } } func stopBackgroundSync() { syncTimer?.invalidate() syncTimer = nil } private func performBackgroundSync() async { // Sync chain data do { let client = ElectrumClient(server: "electrum.blockstream.info") try await syncWithElectrum(client: client) } catch { print("Chain sync failed: \\(error)") } // Sync gossip data await syncGossip() // Process pending events channelManager.processPendingHtlcForwards() // Persist state LDKManager.shared.persistState() } // MARK: - Helpers private func getRelevantTransactions() -> [[UInt8]] { var txIds: [[UInt8]] = [] // Get from channel manager let channelTxs = channelManager.asConfirm().getRelevantTxids() txIds.append(contentsOf: channelTxs.map { $0.0 }) // Get from chain monitor let monitorTxs = chainMonitor.asConfirm().getRelevantTxids() txIds.append(contentsOf: monitorTxs.map { $0.0 }) return txIds } private func getWatchedAddresses() -> [String] { // Implementation depends on your Filter return LDKManager.shared.filter.getWatchedAddresses() } } // Electrum Client Helper class ElectrumClient { private let server: String struct ConfirmedTransaction { let txid: [UInt8] let rawTx: [UInt8] let height: UInt32 let position: UInt } init(server: String) { self.server = server } func checkReorgs(txIds: [[UInt8]]) async throws -> [[UInt8]] { // Check if transactions are still confirmed var unconfirmed: [[UInt8]] = [] for txid in txIds { let confirmed = try await isTransactionConfirmed(txid: txid) if !confirmed { unconfirmed.append(txid) } } return unconfirmed } func getConfirmedTransactions(addresses: [String]) async throws -> [ConfirmedTransaction] { // Fetch transaction history for addresses var transactions: [ConfirmedTransaction] = [] for address in addresses { let history = try await getAddressHistory(address: address) transactions.append(contentsOf: history) } return transactions } func getChainTip() async throws -> ([UInt8], UInt32) { // Get current best block // Implementation depends on Electrum protocol return ([], 0) } // Additional helper methods... }`.trim(), fee_estimation: ` // Fee estimation implementation in Swift import LightningDevKit class LDKFeeEstimator: FeeEstimator { private var feeRates: [ConfirmationTarget: UInt32] = [:] private let minFeeRate: UInt32 = 253 // 1 sat/vbyte private let defaultFeeRates: [ConfirmationTarget: UInt32] = [ .onChainSweep: 5000, // 20 sat/vbyte .maxAllowedNonAnchorChannelRemoteFee: 25000, // 100 sat/vbyte .minAllowedAnchorChannelRemoteFee: 253, // 1 sat/vbyte .minAllowedNonAnchorChannelRemoteFee: 253, // 1 sat/vbyte .anchorChannelFee: 1000, // 4 sat/vbyte .nonAnchorChannelFee: 2000, // 8 sat/vbyte .channelCloseMinimum: 500, // 2 sat/vbyte .outputSpendingFee: 3000 // 12 sat/vbyte ] override init() { super.init() self.feeRates = defaultFeeRates startFeeUpdateTimer() } override func getEstSatPer1000Weight(confirmationTarget: ConfirmationTarget) -> UInt32 { return feeRates[confirmationTarget] ?? defaultFeeRates[confirmationTarget] ?? minFeeRate } // Update fees from external source func updateFeeEstimates() async { do { // Fetch from mempool.space API let url = URL(string: "https://mempool.space/api/v1/fees/recommended")! let (data, _) = try await URLSession.shared.data(from: url) struct FeeRecommendation: Codable { let fastestFee: Int let halfHourFee: Int let hourFee: Int let economyFee: Int let minimumFee: Int } let fees = try JSONDecoder().decode(FeeRecommendation.self, from: data) // Convert sat/vbyte to sat/1000 weight // 1 vbyte = 4 weight units, so sat/vbyte * 250 = sat/1000 weight feeRates[.onChainSweep] = UInt32(fees.fastestFee * 250) feeRates[.maxAllowedNonAnchorChannelRemoteFee] = UInt32(fees.fastestFee * 250 * 5) // 5x for max feeRates[.anchorChannelFee] = UInt32(fees.halfHourFee * 250) feeRates[.nonAnchorChannelFee] = UInt32(fees.halfHourFee * 250) feeRates[.channelCloseMinimum] = UInt32(fees.economyFee * 250) feeRates[.outputSpendingFee] = UInt32(fees.hourFee * 250) // Ensure minimum rates for (target, _) in feeRates { if let rate = feeRates[target] { feeRates[target] = max(rate, minFeeRate) } } print("Updated fee estimates: \\(fees)") } catch { print("Failed to update fee estimates: \\(error)") } } private func startFeeUpdateTimer() { Timer.scheduledTimer(withTimeInterval: 300, repeats: true) { _ in Task { await self.updateFeeEstimates() } } // Initial update Task { await updateFeeEstimates() } } } // SwiftUI Fee Estimator View struct FeeEstimatorView: View { @StateObject private var feeEstimator = FeeEstimatorViewModel() var body: some View { List { Section("Current Fee Rates") { FeeRateRow( label: "High Priority", description: "~10 minutes", satPerVbyte: feeEstimator.highPriority ) FeeRateRow( label: "Medium Priority", description: "~30 minutes", satPerVbyte: feeEstimator.mediumPriority ) FeeRateRow( label: "Low Priority", description: "~1 hour", satPerVbyte: feeEstimator.lowPriority ) FeeRateRow( label: "Economy", description: "~24 hours", satPerVbyte: feeEstimator.economy ) } Section("Channel Operations") { Text("Channel Open: ~\\(feeEstimator.channelOpenCost) sats") Text("Channel Close: ~\\(feeEstimator.channelCloseCost) sats") Text("Force Close: ~\\(feeEstimator.forceCloseCost) sats") } Section { HStack { Text("Last Updated") Spacer() Text(feeEstimator.lastUpdated, style: .relative) .foregroundColor(.secondary) } } } .navigationTitle("Fee Estimates") .refreshable { await feeEstimator.refresh() } } } struct FeeRateRow: View { let label: String let description: String let satPerVbyte: Int var body: some View { HStack { VStack(alignment: .leading, spacing: 4) { Text(label) .font(.headline) Text(description) .font(.caption) .foregroundColor(.secondary) } Spacer() Text("\\(satPerVbyte) sat/vB") .font(.system(.body, design: .monospaced)) .foregroundColor(.orange) } .padding(.vertical, 4) } } class FeeEstimatorViewModel: ObservableObject { @Published var highPriority: Int = 0 @Published var mediumPriority: Int = 0 @Published var lowPriority: Int = 0 @Published var economy: Int = 0 @Published var lastUpdated = Date() private let feeEstimator: LDKFeeEstimator init() { self.feeEstimator = LDKManager.shared.feeEstimator updateRates() } var channelOpenCost: Int { // Approximate channel open transaction size: 200 vbytes return mediumPriority * 200 } var channelCloseCost: Int { // Approximate cooperative close: 150 vbytes return lowPriority * 150 } var forceCloseCost: Int { // Force close with justice transaction: 300 vbytes return highPriority * 300 } func refresh() async { await feeEstimator.updateFeeEstimates() updateRates() } private func updateRates() { // Convert from sat/1000weight to sat/vbyte highPriority = Int(feeEstimator.getEstSatPer1000Weight(confirmationTarget: .onChainSweep) / 250) mediumPriority = Int(feeEstimator.getEstSatPer1000Weight(confirmationTarget: .anchorChannelFee) / 250) lowPriority = Int(feeEstimator.getEstSatPer1000Weight(confirmationTarget: .nonAnchorChannelFee) / 250) economy = Int(feeEstimator.getEstSatPer1000Weight(confirmationTarget: .channelCloseMinimum) / 250) lastUpdated = Date() } }`.trim(), routing: ` // Lightning routing implementation in Swift import LightningDevKit class LightningRouter { private let router: Bindings.DefaultRouter private let networkGraph: Bindings.NetworkGraph private let scorer: Bindings.MultiThreadedLockableScore private let logger: Bindings.Logger init(networkGraph: Bindings.NetworkGraph, scorer: Bindings.MultiThreadedLockableScore, logger: Bindings.Logger, keysManager: Bindings.KeysManager) { self.networkGraph = networkGraph self.scorer = scorer self.logger = logger self.router = Bindings.DefaultRouter( networkGraph: networkGraph, logger: logger, randomSeedBytes: keysManager.asEntropySource().getSecureRandomBytes(), scorer: scorer, scoreParams: Bindings.ProbabilisticScoringFeeParameters.initWithDefault() ) } func findRoute( paymentParams: PaymentParameters, amountMsat: UInt64, payerPubkey: [UInt8] ) -> Result_RouteLightningErrorZ { let channelManager = LDKManager.shared.channelManager let channels = channelManager.listUsableChannels() let routeParams = RouteParameters( paymentParamsArg: paymentParams, finalValueMsatArg: amountMsat, maxTotalRoutingFeeMsatArg: amountMsat / 100 // 1% max fee ) return router.findRoute( payer: payerPubkey, routeParams: routeParams, firstHops: channels, inflightHtlcs: InFlightHtlcs() ) } func findRouteForInvoice(invoice: Bolt11Invoice) -> RouteResult { guard let paymentParams = paymentParametersFromInvoice(invoice: invoice) else { return .failure(.invalidInvoice) } let amountMsat = invoice.amountMilliSatoshis()?.getValue() ?? 0 guard amountMsat > 0 else { return .failure(.zeroAmount) } let ourNodeId = LDKManager.shared.channelManager.getOurNodeId() let routeResult = findRoute( paymentParams: paymentParams.recipientOnion, amountMsat: amountMsat, payerPubkey: ourNodeId ) if let route = routeResult.getValue() { return .success(RouteInfo(from: route)) } else if let error = routeResult.getError() { return .failure(.routingError(error.getDescription())) } else { return .failure(.unknownError) } } // Route analysis func analyzeRoute(_ route: Route) -> RouteAnalysis { let hops = route.getHops() var totalFees: UInt64 = 0 var totalCltv: UInt32 = 0 var hopDetails: [HopDetail] = [] for (index, hop) in hops.enumerated() { let fee = hop.getFeeMsat() totalFees += fee totalCltv += hop.getCltvExpiryDelta() hopDetails.append(HopDetail( nodeId: Data(hop.getPubkey()).hexString, shortChannelId: hop.getShortChannelId(), feeMsat: fee, cltvDelta: hop.getCltvExpiryDelta() )) } return RouteAnalysis( hops: hopDetails, totalFeeMsat: totalFees, totalCltvDelta: totalCltv, successProbability: estimateSuccessProbability(route) ) } private func estimateSuccessProbability(_ route: Route) -> Double { // Simple probability estimate based on number of hops let hopCount = route.getHops().count return max(0.5, 1.0 - (Double(hopCount) * 0.1)) } } // Route models enum RouteResult { case success(RouteInfo) case failure(RouteError) } enum RouteError { case invalidInvoice case zeroAmount case noRoute case routingError(String) case unknownError } struct RouteInfo { let hops: [HopInfo] let totalFeeMsat: UInt64 let totalAmountMsat: UInt64 init(from route: Route) { self.hops = route.getHops().map { HopInfo(from: $0) } self.totalFeeMsat = route.getTotalFees() self.totalAmountMsat = route.getTotalAmount() } } struct HopInfo { let pubkey: String let shortChannelId: UInt64 let feeMsat: UInt64 let cltvExpiryDelta: UInt32 init(from hop: RouteHop) { self.pubkey = Data(hop.getPubkey()).hexString self.shortChannelId = hop.getShortChannelId() self.feeMsat = hop.getFeeMsat() self.cltvExpiryDelta = hop.getCltvExpiryDelta() } } struct RouteAnalysis { let hops: [HopDetail] let totalFeeMsat: UInt64 let totalCltvDelta: UInt32 let successProbability: Double } struct HopDetail { let nodeId: String let shortChannelId: UInt64 let feeMsat: UInt64 let cltvDelta: UInt32 } // SwiftUI Route Visualization struct RouteVisualizationView: View { let route: RouteInfo var body: some View { ScrollView { VStack(alignment: .leading, spacing: 16) { // Route summary VStack(alignment: .leading, spacing: 8) { Text("Route Summary") .font(.headline) HStack { Label("Total Fee", systemImage: "bitcoinsign.circle") Spacer() Text("\\(route.totalFeeMsat / 1000) sats") .fontWeight(.medium) } HStack { Label("Hops", systemImage: "arrow.right.circle") Spacer() Text("\\(route.hops.count)") .fontWeight(.medium) } } .padding() .background(Color(UIColor.secondarySystemBackground)) .cornerRadius(12) // Route path Text("Route Path") .font(.headline) .padding(.top) ForEach(Array(route.hops.enumerated()), id: \\.offset) { index, hop in HopView(hop: hop, index: index, isLast: index == route.hops.count - 1) } } .padding() } .navigationTitle("Payment Route") } } struct HopView: View { let hop: HopInfo let index: Int let isLast: Bool var body: some View { VStack(alignment: .leading, spacing: 0) { HStack { // Hop indicator ZStack { Circle() .fill(Color.blue) .frame(width: 30, height: 30) Text("\\(index + 1)") .font(.caption) .fontWeight(.bold) .foregroundColor(.white) } // Hop details VStack(alignment: .leading, spacing: 4) { Text(hop.pubkey.prefix(16) + "...") .font(.system(.caption, design: .monospaced)) HStack { Text("Channel: \\(hop.shortChannelId)") .font(.caption2) .foregroundColor(.secondary) Spacer() Text("Fee: \\(hop.feeMsat) msat") .font(.caption2) .foregroundColor(.orange) } } .padding(.leading, 8) } if !isLast { // Connection line Rectangle() .fill(Color.blue.opacity(0.3)) .frame(width: 2, height: 30) .offset(x: 15) } } } }`.trim(), background_tasks: ` // iOS Background task implementation for Lightning import BackgroundTasks import LightningDevKit class LightningBackgroundTaskManager { static let shared = LightningBackgroundTaskManager() // Task identifiers static let syncTaskId = "com.yourapp.lightning.sync" static let monitorTaskId = "com.yourapp.lightning.monitor" static let maintenanceTaskId = "com.yourapp.lightning.maintenance" private var activeTasks: Set<BGTask> = [] func registerBackgroundTasks() { // Register sync task BGTaskScheduler.shared.register( forTaskWithIdentifier: Self.syncTaskId, using: nil ) { task in self.handleSyncTask(task as! BGProcessingTask) } // Register monitor task BGTaskScheduler.shared.register( forTaskWithIdentifier: Self.monitorTaskId, using: nil ) { task in self.handleMonitorTask(task as! BGAppRefreshTask) } // Register maintenance task BGTaskScheduler.shared.register( forTaskWithIdentifier: Self.maintenanceTaskId, using: nil ) { task in self.handleMaintenanceTask(task as! BGProcessingTask) } } func scheduleBackgroundTasks() { scheduleSyncTask() scheduleMonitorTask() scheduleMaintenanceTask() } // MARK: - Sync Task (Heavy processing) private func scheduleSyncTask() { let request = BGProcessingTaskRequest(identifier: Self.syncTaskId) request.requiresNetworkConnectivity = true request.requiresExternalPower = false request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60) // 15 minutes do { try BGTaskScheduler.shared.submit(request) } catch { print("Failed to schedule sync task: \\(error)") } } private func handleSyncTask(_ task: BGProcessingTask) { activeTasks.insert(task) // Schedule next sync scheduleSyncTask() // Set expiration handler task.expirationHandler = { self.cancelSync() task.setTaskCompleted(success: false) self.activeTasks.remove(task) } // Perform sync Task { let success = await performFullSync() task.setTaskCompleted(success: success) self.activeTasks.remove(task) } } private func performFullSync() async -> Bool { do { // Initialize LDK if needed if !LDKManager.shared.isInitialized { try await LDKManager.shared.initialize() } // Sync to chain tip try await LDKManager.shared.syncToChainTip() // Process pending events LDKManager.shared.processPendingEvents() // Update network graph await LDKManager.shared.syncNetworkGraph() // Check for incoming payments let receivedPayments = await checkIncomingPayments() if !receivedPayments.isEmpty { notifyPaymentsReceived(receivedPayments) } // Persist state LDKManager.shared.persistState() return true } catch { print("Background sync failed: \\(error)") return false } } // MARK: - Monitor Task (Lightweight) private func scheduleMonitorTask() { let request = BGAppRefreshTaskRequest(identifier: Self.monitorTaskId) request.earliestBeginDate = Date(timeIntervalSinceNow: 30 * 60) // 30 minutes do { try BGTaskScheduler.shared.submit(request) } catch { print("Failed to schedule monitor task: \\(error)") } } private func handleMonitorTask(_ task: BGAppRefreshTask) { activeTasks.insert(task) // Schedule next monitor scheduleMonitorTask() task.expirationHandler = { task.setTaskCompleted(success: false) self.activeTasks.remove(task) } // Quick monitor check Task { let hasUpdates = await performQuickMonitor() if hasUpdates { // Schedule immediate sync if needed scheduleSyncTask() } task.setTaskCompleted(success: true) self.activeTasks.remove(task) } } private func performQuickMonitor() async -> Bool { // Quick check for channel updates or payments guard let lastBlockHeight = UserDefaults.standard.object(forKey: "lastBlockHeight") as? UInt32 else { return true // Need sync } // Check current block height let currentHeight = await getCurrentBlockHeight() return currentHeight > lastBlockHeight + 6 // More than 1 hour of blocks } // MARK: - Maintenance Task private func scheduleMaintenanceTask() { let request = BGProcessingTaskRequest(identifier: Self.maintenanceTaskId) request.requiresNetworkConnectivity = false request.requiresExternalPower = false request.earliestBeginDate = Date(timeIntervalSinceNow: 24 * 60 * 60) // Daily do { try BGTaskScheduler.shared.submit(request) } catch { print("Failed to schedule maintenance task: \\(error)") } } private func handleMaintenanceTask(_ task: BGProcessingTask) { activeTasks.insert(task) // Schedule next maintenance scheduleMaintenanceTask() task.expirationHandler = { task.setTaskCompleted(success: false) self.activeTasks.remove(task) } // Perform maintenance Task { await performMaintenance() task.setTaskCompleted(success: true) self.activeTasks.remove(task) } } private func performMaintenance() async { // Clean up old data cleanupOldPayments() // Compact database compactPersistentStorage() // Prune network graph pruneNetworkGraph() // Backup critical data await performBackup() } // MARK: - Helpers private func checkIncomingPayments() async -> [Payment] { // Check for new payments since last check let lastCheck = UserDefaults.standard.object(forKey: "lastPaymentCheck") as? Date ?? Date.distantPast let payments = await LDKManager.shared.getPaymentsSince(date: lastCheck) UserDefaults.standard.set(Date(), forKey: "lastPaymentCheck") return payments.filter { $0.direction == .inbound } } private func notifyPaymentsReceived(_ payments: [Payment]) { for payment in payments { LightningNotificationService.notifyPaymentReceived( amountMsat: UInt64(payment.amountMsat), description: payment.description ) } } private func cancelSync() { // Cancel ongoing sync operations LDKManager.shared.cancelSync() } private func cleanupOldPayments() { // Remove payments older than 90 days let cutoffDate = Date().addingTimeInterval(-90 * 24 * 60 * 60) PaymentStore.shared.deletePaymentsBefore(date: cutoffDate) } private func compactPersistentStorage() { // Compact LDK persistent storage LDKManager.shared.compactStorage() } private func pruneNetworkGraph() { // Remove old network graph data let networkGraph = LDKManager.shared.networkGraph let currentTime = UInt64(Date().timeIntervalSince1970) networkGraph.removeStaleChannels(currentUnixTimestamp: currentTime) } private func performBackup() async { do { let backup = try await LDKManager.shared.createBackup() try await BackupManager.shared.saveToICloud(backup) } catch { print("Backup failed: \\(error)") } } private func getCurrentBlockHeight() async -> UInt32 { // Fetch from your block source return 800000 // Placeholder } } // App Delegate Integration extension AppDelegate { func application( _ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? ) -> Bool { // Register background tasks LightningBackgroundTaskManager.shared.registerBackgroundTasks() // Schedule initial tasks LightningBackgroundTaskManager.shared.scheduleBackgroundTasks() return true } func applicationDidEnterBackground(_ application: UIApplication) { // Schedule background tasks when entering background LightningBackgroundTaskManager.shared.scheduleBackgroundTasks() } }`.trim() }; try { const code = codeExamples[args.operation]; if (!code) { throw new Error(`Unknown operation: ${args.operation}`); } return { content: [{ type: 'text', text: JSON.stringify({ success: true, operation: args.operation, swiftCode: code }, null, 2) }] }; } catch (error) { return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error instanceof Error ? error.message : 'Unknown error' }, null, 2) }], isError: true }; } } };
• src/tools/getSwiftCode.ts:6-25 (schema)

  Input schema defining the 'operation' parameter with specific enum values for different LDK Swift code examples.
  inputSchema: { type: 'object', properties: { operation: { type: 'string', enum: [ 'channel_manager_setup', 'peer_connection', 'event_handling', 'persistence', 'network_sync', 'fee_estimation', 'routing', 'background_tasks' ], description: 'Type of operation to get Swift code for' } }, required: ['operation'] },
• src/index.ts:30-62 (registration)

  Imports the getSwiftCodeTool and adds it to the central 'tools' array which is used by the MCP server for tool listing and execution.
  import { getSwiftCodeTool } from './tools/getSwiftCode.js'; import { getArchitectureTool } from './tools/getArchitecture.js'; import { testScenarioTool } from './tools/testScenario.js'; import { networkGraphTool } from './tools/networkGraph.js'; import { eventHandlingTool } from './tools/eventHandling.js'; import { chainSyncTool } from './tools/chainSync.js'; // Aggregate all tools const tools = [ generateInvoiceTool, payInvoiceTool, getChannelStatusTool, getNodeInfoTool, backupStateTool, keychainTestTool, backgroundTestTool, pushNotificationTool, biometricAuthTool, createChannelTool, closeChannelTool, getBalanceTool, decodeInvoiceTool, listPaymentsTool, estimateFeeTool, generateMnemonicTool, deriveAddressTool, getSwiftCodeTool, getArchitectureTool, testScenarioTool, networkGraphTool, eventHandlingTool, chainSyncTool, ];