Merge pull request #98 from lightningdevkit/2023-03-prerelease-114

Author: arik-so

.github/actions/install-dependencies/action.yml

@@ -22,8 +22,8 @@ runs:
             run: |
                 echo `pwd`
                 mkdir -p ${{ inputs.destination }}/bin
-                git clone --branch 2022-12-0.0.113-java-bindings https://github.com/TheBlueMatt/rust-lightning ${{ inputs.destination }}/rust-lightning
-                git clone --branch v0.0.113.0 https://github.com/lightningdevkit/ldk-c-bindings ${{ inputs.destination }}/ldk-c-bindings
+                git clone --branch 2023-02-0.0.114-java-bindings https://github.com/TheBlueMatt/rust-lightning ${{ inputs.destination }}/rust-lightning
+                git clone --branch v0.0.114.1 https://github.com/lightningdevkit/ldk-c-bindings ${{ inputs.destination }}/ldk-c-bindings
         -   name: Install Rust, required targets
             if: ${{ inputs.configureRustNightly == 'true' }}
             shell: bash

.github/workflows/swift.yml

@@ -17,8 +17,12 @@ jobs:
                 uses: actions/checkout@v3
             -   name: Install native Rust toolchain, Valgrind, and build utilities
                 run: |
+                    # sudo apt-get purge grub\*
+                    # sudo apt-get --only-upgrade install grub-efi-amd64-signed
+                    # sudo apt-get autoremove
+                    # sudo update-grub
                     sudo apt-get update
-                    sudo apt-get -y upgrade
+                    # sudo apt-get -y upgrade
                     sudo apt-get -y install cargo valgrind lld git g++ clang curl
             -   name: Install Dependencies
                 uses: ./.github/actions/install-dependencies

README.md

@@ -58,13 +58,13 @@ In order to generate these bindings from scratch, you will need to clone two dep
 **[rust-lightning](https://github.com/lightningdevkit/rust-lightning)**, (a specific branch built for bindings compatibility):
 
 ```shell
-git clone --branch 2022-12-0.0.113-java-bindings https://github.com/TheBlueMatt/rust-lightning /path/to/rust-lightning
+git clone --branch 2023-02-0.0.114-java-bindings https://github.com/TheBlueMatt/rust-lightning /path/to/rust-lightning
 ```
 
 **[ldk-c-bindings](https://github.com/lightningdevkit/ldk-c-bindings)**:
 
 ```shell
-git clone --branch v0.0.113.1 https://github.com/lightningdevkit/ldk-c-bindings /path/to/ldk-c-bindings
+git clone --branch v0.0.114.1 https://github.com/lightningdevkit/ldk-c-bindings /path/to/ldk-c-bindings
 ```
 
 Take note of where you clone these directories, it's best you save the absolute path somewhere handy for the rest of the remaining steps.

ci/LDKSwift/Sources/LDKSwift/batteries/ChannelManagerConstructor.swift

@@ -12,34 +12,34 @@ import LDKHeaders
 import XCTest
 
 public class HumanObjectPeerTestInstance {
-    
+
     private let configuration: Configuration
-    
+
     public class Configuration {
 //
         public var useFilter: Bool = false;
         public var useRouter: Bool = false;
         public var shouldRecipientRejectPayment: Bool = false;
-        
+
         // public var nice_close: Bool = false;
         // public var use_km_wrapper: Bool = false;
         // public var use_manual_watch: Bool = false;
         // public var reload_peers: Bool = false;
         // public var break_cross_peer_refs: Bool = false;
         // public var use_nio_peer_handler: Bool = false;
-        
+
         private class func listCustomizeableProperties() -> [String] {
             return ["useFilter", "useRouter", "shouldRecipientRejectPayment"]
         }
-        
+
         public class func combinationCount() -> UInt {
             return 1 << self.listCustomizeableProperties().count
         }
-        
+
     }
-    
-    
-    
+
+
+
     public init(configuration: Configuration) {
         self.configuration = configuration
     }
@@ -54,8 +54,7 @@ public class HumanObjectPeerTestInstance {
         var filterAdditions: Set<String>
         let monitors: [String: ChannelMonitor]
         private(set) var filter: Filter?
-        private(set) var keysInterface: KeysInterface!
-        private(set) var explicitKeysManager: KeysManager?
+        private(set) var explicitKeysManager: KeysManager!
         private(set) var router: GossipSync!
         private(set) var channelManager: ChannelManager!
         private(set) var peerManager: PeerManager!
@@ -196,18 +195,18 @@ public class HumanObjectPeerTestInstance {
             }
         }
 
-        fileprivate class TestKeysInterface: KeysInterface {
+        fileprivate class TestKeysInterface: SignerProvider {
 
             weak var master: Peer!
-            let interface: KeysInterface
+            let interface: SignerProvider
 
-            fileprivate init(master: Peer, underlyingInterface: KeysInterface) {
+            fileprivate init(master: Peer, underlyingInterface: SignerProvider) {
                 self.master = master
                 self.interface = underlyingInterface
                 super.init()
             }
-            
-			override func deriveChannelSigner(channelValueSatoshis: UInt64, channelKeysId: [UInt8]) -> Bindings.Sign {
+
+			override func deriveChannelSigner(channelValueSatoshis: UInt64, channelKeysId: [UInt8]) -> Bindings.WriteableEcdsaChannelSigner {
                 let ck = self.interface.deriveChannelSigner(channelValueSatoshis: channelValueSatoshis, channelKeysId: channelKeysId)
                 return ck
             }
@@ -230,17 +229,18 @@ public class HumanObjectPeerTestInstance {
                     await master.pendingEventTracker.addEvent(event: event)
                 }
             }
-            
+
             override func persistManager(channelManager: Bindings.ChannelManager) -> Bindings.Result_NoneErrorZ {
                 .initWithOk()
             }
-            
+
             override func persistScorer(scorer: Bindings.WriteableScore) -> Bindings.Result_NoneErrorZ {
                 .initWithOk()
             }
-            
+
             override func persistGraph(networkGraph: Bindings.NetworkGraph) -> Bindings.Result_NoneErrorZ {
-                .initWithOk()
+                let writtenGraph = networkGraph.write();
+                return Result_NoneErrorZ.initWithOk()
             }
 
         }
@@ -284,13 +284,11 @@ public class HumanObjectPeerTestInstance {
             let timestamp_seconds = UInt64(NSDate().timeIntervalSince1970)
             let timestamp_nanos = UInt32(truncating: NSNumber(value: timestamp_seconds * 1000 * 1000))
             let keysManager = KeysManager(seed: keySeed, startingTimeSecs: timestamp_seconds, startingTimeNanos: timestamp_nanos)
-            
-            self.keysInterface = keysManager.asKeysInterface()
             self.explicitKeysManager = keysManager
 
             if master.configuration.useRouter {
-                let networkGraph = NetworkGraph(genesisHash: [UInt8](repeating: 0, count: 32), logger: self.logger)
-                self.router = GossipSync.initWithP2P(a: P2PGossipSync(networkGraph: networkGraph, chainAccess: nil, logger: self.logger))
+                let networkGraph = NetworkGraph(network: .Regtest, logger: self.logger)
+                self.router = GossipSync.initWithP2P(a: P2PGossipSync(networkGraph: networkGraph, utxoLookup: nil, logger: self.logger))
             }else{
                 self.router = GossipSync.none()
             }
@@ -302,16 +300,27 @@ public class HumanObjectPeerTestInstance {
             do {
                 // channel manager constructor is mandatory
 
-                let graph = NetworkGraph(genesisHash: [UInt8](repeating: 0, count: 32), logger: self.logger)
-
-                self.constructor = ChannelManagerConstructor(network: .Bitcoin, userConfig: UserConfig.initWithDefault(), currentBlockchainTipHash: [UInt8](repeating: 0, count: 32), currentBlockchainTipHeight: 0, keysInterface: self.keysInterface, feeEstimator: self.feeEstimator, chainMonitor: self.chainMonitor!, netGraph: graph, txBroadcaster: self.txBroadcaster, logger: self.logger)
+                let graph = NetworkGraph(network: .Regtest, logger: self.logger)
 
                 let scoringParams = ProbabilisticScoringParameters.initWithDefault()
                 let probabalisticScorer = ProbabilisticScorer(params: scoringParams, networkGraph: graph, logger: self.logger)
                 let score = probabalisticScorer.asScore()
                 let multiThreadedScorer = MultiThreadedLockableScore(score: score)
-
-                self.constructor?.chainSyncCompleted(persister: TestChannelManagerPersister(master: self), scorer: multiThreadedScorer)
+                
+                let constructionParameters = ChannelManagerConstructionParameters(
+                    config: UserConfig.initWithDefault(),
+                    entropySource: self.explicitKeysManager.asEntropySource(),
+                    nodeSigner: self.explicitKeysManager.asNodeSigner(),
+                    signerProvider: self.explicitKeysManager.asSignerProvider(),
+                    feeEstimator: self.feeEstimator,
+                    chainMonitor: self.chainMonitor!,
+                    txBroadcaster: self.txBroadcaster,
+                    logger: self.logger,
+                    scorer: multiThreadedScorer
+                )
+                self.constructor = ChannelManagerConstructor(network: .Bitcoin, currentBlockchainTipHash: [UInt8](repeating: 0, count: 32), currentBlockchainTipHeight: 0, netGraph: graph, params: constructionParameters)
+
+                self.constructor?.chainSyncCompleted(persister: TestChannelManagerPersister(master: self))
                 self.channelManager = self.constructor!.channelManager
                 self.peerManager = self.constructor!.peerManager
             }
@@ -324,9 +333,20 @@ public class HumanObjectPeerTestInstance {
 
             do {
                 // channel manager constructor is mandatory
-                let graph = NetworkGraph(genesisHash: [UInt8](repeating: 0, count: 32), logger: self.logger)
-                self.constructor = ChannelManagerConstructor(network: .Bitcoin, userConfig: UserConfig.initWithDefault(), currentBlockchainTipHash: [UInt8](repeating: 0, count: 32), currentBlockchainTipHeight: 0, keysInterface: self.keysInterface, feeEstimator: self.feeEstimator, chainMonitor: self.chainMonitor!, netGraph: graph, txBroadcaster: self.txBroadcaster, logger: self.logger)
-                self.constructor?.chainSyncCompleted(persister: TestChannelManagerPersister(master: self), scorer: nil)
+                let graph = NetworkGraph(network: .Bitcoin, logger: self.logger)
+                
+                let constructionParameters = ChannelManagerConstructionParameters(
+                    config: UserConfig.initWithDefault(),
+                    entropySource: self.explicitKeysManager.asEntropySource(),
+                    nodeSigner: self.explicitKeysManager.asNodeSigner(),
+                    signerProvider: self.explicitKeysManager.asSignerProvider(),
+                    feeEstimator: self.feeEstimator,
+                    chainMonitor: self.chainMonitor!,
+                    txBroadcaster: self.txBroadcaster,
+                    logger: self.logger
+                )
+                self.constructor = ChannelManagerConstructor(network: .Bitcoin, currentBlockchainTipHash: [UInt8](repeating: 0, count: 32), currentBlockchainTipHeight: 0, netGraph: graph, params: constructionParameters)
+                self.constructor?.chainSyncCompleted(persister: TestChannelManagerPersister(master: self))
                 self.channelManager = self.constructor!.channelManager
                 Task {
                     let events = await original.pendingEventTracker.getEvents()
@@ -400,7 +420,7 @@ public class HumanObjectPeerTestInstance {
                 let blockHeader = block.calculateHeader()
                 self.channelManager.asConfirm().transactionsConfirmed(header: blockHeader, txdata: transactionTuples, height: height)
                 self.channelManager.asConfirm().bestBlockUpdated(header: blockHeader, height: height)
-                
+
                 for (_, monitor) in self.monitors {
                     let connectionResult = monitor.blockConnected(header: blockHeader, txdata: transactionTuples, height: height, broadcaster: self.txBroadcaster, feeEstimator: self.feeEstimator, logger: self.logger)
                     XCTAssertEqual(connectionResult.count, expectedMonitorUpdateLength)
@@ -422,10 +442,10 @@ public class HumanObjectPeerTestInstance {
 
 
     fileprivate func connectPeers(peerA: Peer, peerB: Peer) {
-        
+
         let connectionResult = peerA.tcpSocketHandler?.connect(address: "127.0.0.1", port: peerB.tcpPort!, theirNodeId: peerB.nodeId!)
         print("connection result: \(connectionResult)")
-        
+
     }
 
     func test_multiple_peer_connections() async {
@@ -619,22 +639,25 @@ public class HumanObjectPeerTestInstance {
         let originalChannelBalanceBToA = channelBToA.getBalanceMsat()
         print("original balance A->B mSats: \(originalChannelBalanceAToB)")
         print("original balance B->A mSats: \(originalChannelBalanceBToA)")
-        
+
         let logger = TestLogger()
 
         do {
             // create invoice for 10k satoshis to pay to peer2
 
-            let invoiceResult = Bindings.swiftCreateInvoiceFromChannelmanager(channelmanager: peer2.channelManager, keysManager: peer2.keysInterface, logger: logger, network: .Bitcoin, amtMsat: SEND_MSAT_AMOUNT_A_TO_B, description: "Invoice description", invoiceExpiryDeltaSecs: 60)
+            let invoiceResult = Bindings.createInvoiceFromChannelmanager(channelmanager: peer2.channelManager, nodeSigner: peer2.explicitKeysManager.asNodeSigner(), logger: logger, network: .Bitcoin, amtMsat: SEND_MSAT_AMOUNT_A_TO_B, description: "Invoice description", invoiceExpiryDeltaSecs: 60, minFinalCltvExpiryDelta: 24)
+            if let invoiceError = invoiceResult.getError(){
+                let creationError = invoiceError.getValueAsCreationError()
+                print("creation error: \(creationError)")
+            }
             let invoice = invoiceResult.getValue()!
             print("Invoice: \(invoice.toStr())")
 
             let recreatedInvoice = Invoice.fromStr(s: invoice.toStr())
             XCTAssertTrue(recreatedInvoice.isOk())
 
             let channelManagerConstructor = peer1.constructor!
-            let invoicePayer = channelManagerConstructor.payer!
-            let invoicePaymentResult = invoicePayer.payInvoice(invoice: invoice)
+            let invoicePaymentResult = Bindings.payInvoice(invoice: invoice, retryStrategy: Bindings.Retry.initWithAttempts(a: 3), channelmanager: channelManagerConstructor.channelManager)
             XCTAssertTrue(invoicePaymentResult.isOk())
 
             do {
@@ -693,13 +716,14 @@ public class HumanObjectPeerTestInstance {
                     "payment_failed_permanently": paymentPathFailed.getPaymentFailedPermanently(),
                     "short_channel_id": paymentPathFailed.getShortChannelId(),
                     "path": paymentPathFailed.getPath().map { $0.getShortChannelId() },
-                    "network_update": paymentPathFailed.getNetworkUpdate().debugDescription
+                    "retry": paymentPathFailed.getRetry(),
+                    "failure": paymentPathFailed.getFailure()
                 ]
-                
+
                 print("payent path failure: \(failureDescriptor)")
                 print("here")
                 return
-                
+
             } else {
                 // process payment
                 let peer1Events = try! await peer1.getManagerEvents(expectedCount: 2)
@@ -743,19 +767,19 @@ public class HumanObjectPeerTestInstance {
             print("pre-payment balance A->B mSats: \(prePaymentBalanceAToB)")
             print("pre-payment balance B->A mSats: \(prePaymentBalanceBToA)")
 
-            let invoiceResult = Bindings.swiftCreateInvoiceFromChannelmanager(channelmanager: peer1.channelManager, keysManager: peer1.keysInterface, logger: logger, network: .Bitcoin, amtMsat: nil, description: "Second invoice description", invoiceExpiryDeltaSecs: 60)
+            let invoiceResult = Bindings.createInvoiceFromChannelmanager(channelmanager: peer1.channelManager, nodeSigner: peer1.explicitKeysManager.asNodeSigner(), logger: logger, network: .Bitcoin, amtMsat: nil, description: "Second invoice description", invoiceExpiryDeltaSecs: 60, minFinalCltvExpiryDelta: 24)
             let invoice = invoiceResult.getValue()!
             print("Implicit amount invoice: \(invoice.toStr())")
 
 			let invoiceString = invoice.toStr()
             let recreatedInvoice = Invoice.fromStr(s: invoiceString)
             XCTAssertTrue(recreatedInvoice.isOk())
 
-            let invoicePaymentResult = peer2.constructor!.payer!.payZeroValueInvoice(invoice: invoice, amountMsats: SEND_MSAT_AMOUNT_B_TO_A)
+            let invoicePaymentResult = Bindings.payZeroValueInvoice(invoice: invoice, amountMsats: SEND_MSAT_AMOUNT_B_TO_A, retryStrategy: Retry.initWithAttempts(a: 3), channelmanager: peer2.channelManager)
             if let error = invoicePaymentResult.getError() {
                 print("value type: \(error.getValueType())")
-                if let routingError = error.getValueAsRouting() {
-                    print("routing error: \(routingError.getErr())")
+                if let routingError = error.getValueAsSending() {
+                    print("sending error: \(routingError)")
                 }
             }
             XCTAssertTrue(invoicePaymentResult.isOk())