LDK MCP Server

Instructions

Implementation Reference

• src/tools/getSwiftCode.ts:26-1666 (handler)

  The main handler function that takes an 'operation' argument, selects the corresponding Swift code example from a predefined map, and returns it as JSON-formatted text content.

    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 specifying the required 'operation' parameter as a string enum of LDK operations for which Swift code examples are provided.

  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)

  The tool is imported and added to the central tools array, which is used by the MCP server to handle listTools and callTool requests.

  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,
  ];