Updated tutorials for LDK 0.0.116

Author: Conor Okus

docs/tutorials/building-a-node-with-ldk/closing-a-channel.md

@@ -24,7 +24,7 @@ let channelId: [UInt8] = // Add Channel Id in bytes
 let counterpartyNodeId: [UInt8] = // Add Counterparty Node Id in bytes
 let res = channelManager.closeChannel(channelId: channelId, counterpartyNodeId: counterpartyNodeId)
 if res!.isOk() {
-    print("Channel Closed")
+    // Channel Closed
 }
 ```
 
@@ -52,19 +52,21 @@ Claim Funds using Custom KeysManager. (Single Fees)
   <template v-slot:swift>
 
 ```Swift
+// Custom KeysManager to get funds directly back to the BDK wallet after Channel Close
 class MyKeysManager {
     let keysManager: KeysManager
-    let signerProvider: MySignerProvider // Use signerProvider instead of asSignerProvider()
-    let wallet: Wallet
-
-    init(seed: [UInt8], startingTimeSecs: UInt64, startingTimeNanos: UInt32, wallet: Wallet) {
+    let signerProvider: MySignerProvider
+    let wallet: BitcoinDevKit.Wallet
+    
+    init(seed: [UInt8], startingTimeSecs: UInt64, startingTimeNanos: UInt32, wallet: BitcoinDevKit.Wallet) {
         self.keysManager = KeysManager(seed: seed, startingTimeSecs: startingTimeSecs, startingTimeNanos: startingTimeNanos)
         self.wallet = wallet
         signerProvider = MySignerProvider()
         signerProvider.myKeysManager = self
     }
 }
 
+// Custom SignerProvider to override getDestinationScript() and getShutdownScriptpubkey()
 class MySignerProvider: SignerProvider {
     weak var myKeysManager: MyKeysManager?
     override func deriveChannelSigner(channelValueSatoshis: UInt64, channelKeysId: [UInt8]) -> Bindings.WriteableEcdsaChannelSigner {
@@ -79,16 +81,16 @@ class MySignerProvider: SignerProvider {
         return myKeysManager!.keysManager.asSignerProvider().readChanSigner(reader: reader)
     }
 
-    override func getDestinationScript() -> [UInt8] {
+    override func getDestinationScript() -> Bindings.Result_ScriptNoneZ {
         do {
             let address = try myKeysManager!.wallet.getAddress(addressIndex: .new)
-            return address.address.scriptPubkey().toBytes()
+            return Bindings.Result_ScriptNoneZ.initWithOk(o: address.address.scriptPubkey().toBytes())
         } catch {
             return myKeysManager!.keysManager.asSignerProvider().getDestinationScript()
         }
     }
-
-    override func getShutdownScriptpubkey() -> Bindings.ShutdownScript {
+    
+    override func getShutdownScriptpubkey() -> Bindings.Result_ShutdownScriptNoneZ {
         do {
             let address = try myKeysManager!.wallet.getAddress(addressIndex: .new).address
             let payload = address.payload()
@@ -132,7 +134,7 @@ class MySignerProvider: SignerProvider {
                 }
                 let res = ShutdownScript.newWitnessProgram(version: ver, program: program)
                 if res.isOk() {
-                    return res.getValue()!
+                    return Bindings.Result_ShutdownScriptNoneZ.initWithOk(o: res.getValue()!)
                 }
             }
             return myKeysManager!.keysManager.asSignerProvider().getShutdownScriptpubkey()
@@ -141,6 +143,7 @@ class MySignerProvider: SignerProvider {
         }
     }
 }
+
 ```
 
   </template>
@@ -170,14 +173,22 @@ func handleEvent(event: Event) {
     if let event = event.getValueAsSpendableOutputs() {
         let outputs = event.getOutputs()
         do {
-            let address = ldkManager!.bdkManager.getAddress(addressIndex: .new)!
+            let address = // Get an address to transfer the funds
             let script = try Address(address: address).scriptPubkey().toBytes()
-            let res = ldkManager?.keysManager?.spendSpendableOutputs(descriptors: outputs, outputs: [], changeDestinationScript: script, feerateSatPer1000Weight: 1000)
-            if res!.isOk() {
-                ldkManager.broadcaster.broadcastTransaction(tx: res!.getValue()!)
+            let res = ldkManager.keysManager.spendSpendableOutputs(
+                descriptors: outputs,
+                outputs: [],
+                changeDestinationScript: script,
+                feerateSatPer1000Weight: 1000,
+                locktime: nil
+            )
+            if res.isOk() {
+                var txs: [[UInt8]] = []
+                txs.append(res.getValue()!)
+                ldkManager.broadcaster.broadcastTransactions(txs: txs)
             }
         } catch {
-            print(error)
+            print(error.localizedDescription)
         }
     }
 }

docs/tutorials/building-a-node-with-ldk/opening-a-channel.md

@@ -68,9 +68,9 @@ userConfig.setChannelHandshakeConfig(val: channelConfig)
 
 let createChannelResults = channelManager.createChannel(
 	theirNetworkKey: pubKey,
-	channelValueSatoshis: amount,
-	pushMsat: pushMsat,
-	userChannelId: userId,
+	channelValueSatoshis: amount, 
+	pushMsat: pushMsat, 
+	userChannelId: userId, 
 	overrideConfig: userConfig
 )
 ```
@@ -81,7 +81,7 @@ let createChannelResults = channelManager.createChannel(
 
 # FundingGenerationReady Event Handling
 
-At this point, an outbound channel has been initiated with your peer and it will appear in `ChannelManager::list_channels`. However, the channel is not yet funded. Once your peer accepts the channel, you will be notified with a `FundingGenerationReady` event. It's then your responsibility to construct the funding transaction and pass it to ChannelManager, which will broadcast it once it receives your channel counterparty's signature.
+At this point, an outbound channel has been initiated with your peer and it will appear in `ChannelManager::list_channels`. However, the channel is not yet funded. Once your peer accepts the channel, you will be notified with a `FundingGenerationReady` event. It's then your responsibility to construct the funding transaction and pass it to ChannelManager, which will broadcast it once it receives your channel counterparty's signature. 
 
 ::: tip Note
 
@@ -180,8 +180,8 @@ if let event = event.getValueAsFundingGenerationReady() {
     let rawTx = buildFundingTx(script: script, amount: channelValue)
     if let rawTx = rawTx {
         channelManager.fundingTransactionGenerated(
-			temporaryChannelId: event.getTemporaryChannelId(),
-			counterpartyNodeId: event.getCounterpartyNodeId(),
+			temporaryChannelId: event.getTemporaryChannelId(), 
+			counterpartyNodeId: event.getCounterpartyNodeId(), 
 			fundingTransaction: rawTx.serialize()
 		)
     }
@@ -208,7 +208,6 @@ func buildFundingTx(script: Script, amount: UInt64) -> Transaction? {
 </CodeSwitcher>
 
 **References:** [Rust `FundingGenerationReady` docs](https://docs.rs/lightning/*/lightning/util/events/enum.Event.html#variant.FundingGenerationReady), [Java `FundingGenerationReady` bindings](https://github.com/lightningdevkit/ldk-garbagecollected/blob/main/src/main/java/org/ldk/structs/Event.java#L95)
-
 # Broadcasting the Funding Transaction
 
 After crafting the funding transaction you'll need to send it to the Bitcoin network where it will hopefully be mined and added to the blockchain. You'll need to watch this transaction and wait for a minimum of 6 confirmations before the channel is ready to use.
@@ -261,8 +260,8 @@ object YourTxBroadcaster : BroadcasterInterface.BroadcasterInterfaceInterface {
 		val transaction = Transaction(uByteArray.toList())
 
 		tx?.let {
-            CoroutineScope(Dispatchers.IO).launch {
-				blockchain.broadcast(transaction)
+            CoroutineScope(Dispatchers.IO).launch { 
+				blockchain.broadcast(transaction) 
 			}
         } ?: throw(IllegalStateException("Broadcaster attempted to broadcast a null transaction"))
 
@@ -277,19 +276,22 @@ object YourTxBroadcaster : BroadcasterInterface.BroadcasterInterfaceInterface {
 
 ```Swift
 // Using BDK (Bitcoin Dev Kit) to broadcast a transaction via the esplora client
+import BitcoinDevKit
+
 class MyBroacaster: BroadcasterInterface {
-    override func broadcastTransaction(tx: [UInt8]) {
+    override func broadcastTransactions(txs: [[UInt8]]) {
         let esploraURL = "esploraUrl"
-		let esploraConfig = EsploraConfig(baseUrl: esploraURL, proxy: nil, concurrency: 5, stopGap: 20, timeout: nil)
+        let esploraConfig = EsploraConfig(baseUrl: esploraURL, proxy: nil, concurrency: 5, stopGap: 20, timeout: nil)
         let blockchainConfig = BlockchainConfig.esplora(config: esploraConfig)
-		let blockchain = Blockchain(config: blockchainConfig)
-
-		do {
-			let transaction = try Transaction(transactionBytes: tx)
-			try blockchain.broadcast(transaction: transaction)
-		} catch {
-			print("Failed to broadcast transaction: \(error.localizedDescription)")
-		}
+        do {
+            let blockchain = try Blockchain(config: blockchainConfig)
+            for tx in txs {
+                let transaction = try Transaction(transactionBytes: tx)
+                try blockchain.broadcast(transaction: transaction)
+            }
+        } catch {
+            print("Failed to broadcast transaction: \(error.localizedDescription)")
+        }
     }
 }
 ```

docs/tutorials/building-a-node-with-ldk/sending-payments.md

@@ -130,22 +130,22 @@ if (parsed_invoice instanceof Result_InvoiceNoneZ.Result_InvoiceNoneZ_OK) {
 
   <template v-slot:swift>
 
-```Swift
-let invoiceStr = // get an invoice from the payee
-let parsedInvoice = Invoice.fromStr(s: invoiceStr)
-
-if parsedInvoice.getValue() != nil {
-  let invoicePaymentResult = Bindings.payInvoice(
-    invoice: invoice,
-    retryStrategy: Bindings.Retry.initWithTimeout(a: 15),
-    channelmanager: channelManager
-  )
-
-  if invoicePaymentResult.isOk() {
-    // Payment Sent
+  ```Swift
+  let invoiceStr = // get an invoice from the payee
+  let parsedInvoice = Bolt11Invoice.fromStr(s: invoiceStr)
+
+  if let invoiceVal = parsedInvoice.getValue() {
+    let invoicePaymentResult = Bindings.payInvoice(
+      invoice: invoiceVal,
+      retryStrategy: Bindings.Retry.initWithTimeout(a: 15),
+      channelmanager: channelManager
+    )
+
+    if invoicePaymentResult.isOk() {
+      // Payment Sent
+    }
   }
-}
-```
+  ```
 
   </template>
 
@@ -202,4 +202,4 @@ if let paymentSentEvent = event.getValueAsPaymentSent() {
 
   </template>
 
-</CodeSwitcher>
+</CodeSwitcher>

docs/tutorials/building-a-node-with-ldk/setting-up-a-channel-manager.md

@@ -266,7 +266,7 @@ retrieving fresh ones every time
 
   ```Swift
   class MyBroacaster: BroadcasterInterface {
-    override func broadcastTransaction(tx: [UInt8]) {
+    override func broadcastTransactions(txs: [[UInt8]]) {
         // Insert code to broadcast the given transaction
     }
   }
@@ -1036,9 +1036,10 @@ if readResult.isOk() {
 }
 
 // If Network Graph does not exist, create a new one
-netGraph = NetworkGraph(network: network, logger: logger)
+let netGraph = NetworkGraph(network: network, logger: logger)
 
-let rgs = RapidGossipSync(networkGraph: netGraph, logger: logger) // Initialise RGS
+// Initialise RGS
+let rgs = RapidGossipSync(networkGraph: netGraph, logger: logger)
 if let lastSync = netGraph.getLastRapidGossipSyncTimestamp(), let snapshot = getSnapshot(lastSyncTimeStamp: lastSync) {
   let timestampSeconds = UInt64(NSDate().timeIntervalSince1970)
   let res = rgs.updateNetworkGraphNoStd(updateData: snapshot, currentTimeUnix: timestampSeconds)
@@ -1055,7 +1056,8 @@ if let lastSync = netGraph.getLastRapidGossipSyncTimestamp(), let snapshot = get
 
 // Get current snapshot from the RGS Server
 func getSnapshot(lastSyncTimeStamp: UInt32) -> [UInt8]? {
-  let url: URL = URL(string: "https://rapidsync.lightningdevkit.org/snapshot/\(lastSyncTimeStamp)")! // Use LDK's RGS Server or use your own Server
+  // Use LDK's RGS Server or use your own Server
+  let url: URL = URL(string: "https://rapidsync.lightningdevkit.org/snapshot/\(lastSyncTimeStamp)")!
   let data = // Use the url to get the data
   if let data = data {
     return [UInt8](data)
@@ -1077,3 +1079,74 @@ func getSnapshot(lastSyncTimeStamp: UInt32) -> [UInt8]? {
 **Optional dependency:** `Access`, a source of chain information. Recommended to be able to verify channels before adding them to the internal network graph.
 
 **References:** [Rust `P2PGossipSync` docs](https://docs.rs/lightning/*/lightning/routing/gossip/struct.P2PGossipSync.html), [`Access` docs](https://docs.rs/lightning/*/lightning/chain/trait.Access.html), [Java `P2PGossipSync` bindings](https://github.com/lightningdevkit/ldk-garbagecollected/blob/main/src/main/java/org/ldk/structs/P2PGossipSync.java), [Rust `RapidGossipSync` docs](https://docs.rs/lightning-rapid-gossip-sync/*/lightning_rapid_gossip_sync/), [Java `RapidGossipSync` bindings](https://github.com/lightningdevkit/ldk-garbagecollected/blob/main/src/main/java/org/ldk/structs/RapidGossipSync.java)
+
+### Optional: Initialize `Probabilistic Scorer`
+
+**You must follow this step if:** TODO
+
+**What it's used for:** TODO
+
+<CodeSwitcher :languages="{rust:'Rust', kotlin:'Kotlin', swift:'Swift'}">
+
+<template v-slot:rust>
+
+```rust
+// TODO: Add Rust Code Here
+```
+
+</template>
+
+<template v-slot:kotlin>
+
+```java
+// TODO: Add Java Code Here
+```
+
+</template>
+
+<template v-slot:swift>
+
+```Swift
+// If Scorer exists, then read from disk
+let serializedScorer = // Read Scorer bytes from file
+let decayParams = ProbabilisticScoringDecayParameters.initWithDefault()
+let serializedProbabilisticScorer = ProbabilisticScorer.read(
+  ser: serializedScorer, 
+  argA: decayParams, 
+  argB: netGraph, 
+  argC: logger
+)
+if let res = serializedProbabilisticScorer.getValue() {
+  let probabilisticScorer = res
+  let score = probabilisticScorer.asScore()
+
+  // Scorer loaded
+  let scorer = MultiThreadedLockableScore(score: score)
+}
+
+// If Scorer does not exist, create a new one
+let decayParams = ProbabilisticScoringDecayParameters.initWithDefault()
+let probabilisticScorer = ProbabilisticScorer(
+  decayParams: decayParams, 
+  networkGraph: netGraph, 
+  logger: logger
+)
+let score = probabilisticScorer.asScore()
+
+// Scorer loaded
+let scorer = MultiThreadedLockableScore(score: score)
+```
+
+</template>
+
+
+</CodeSwitcher>
+
+
+**Implementation notes:** TODO
+
+**Dependencies:** TODO
+
+**Optional dependency:** TODO
+
+**References:** TODO