create util methods and a channel manager constructor battery

Author: arik-so

bindings/batteries/ChannelManagerConstructor.swift

@@ -0,0 +1,69 @@
+//
+//  ChannelManagerConstructor.swift
+//  LDKSwiftARC
+//
+//  Created by Arik Sosman on 5/19/21.
+//
+
+import Foundation
+
+enum InvalidSerializedDataError: Error {
+    case runtimeError
+}
+
+class ChannelManagerConstructor {
+    
+    public let channelManager: ChannelManager
+    /**
+     * The latest block has the channel manager saw. If this is non-null it is a 32-byte block hash.
+     * You should sync the blockchain starting with the block that builds on this block.
+     */
+    public let channel_manager_latest_block_hash: [UInt8]
+    /**
+     * A list of ChannelMonitors and the last block they each saw. You should sync the blockchain on each individually
+     * starting with the block that builds on the hash given.
+     * After doing so (and syncing the blockchain on the channel manager as well), you should call chain_sync_completed()
+     * and then continue to normal application operation.
+     */
+    public private(set) var channel_monitors: [(ChannelMonitor, [UInt8])]
+
+    private let chain_monitor: ChainMonitor
+    
+    init(channel_manager_serialized: [UInt8], channel_monitors_serialized: [[UInt8]], keys_interface: KeysInterface, fee_estimator: FeeEstimator, chain_monitor: ChainMonitor, filter: Filter?, tx_broadcaster: BroadcasterInterface, logger: Logger) throws {
+        
+        var monitors: [LDKChannelMonitor] = []
+        self.channel_monitors = []
+        for index in 0..<channel_monitors_serialized.count {
+            let currentSerializedChannelMonitor = channel_monitors_serialized[index]
+            let res: Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ = UtilMethods.constructor_BlockHashChannelMonitorZ_read(ser: currentSerializedChannelMonitor, arg: keys_interface)
+            if res.cOpaqueStruct?.result_ok != true {
+                throw InvalidSerializedDataError.runtimeError
+            }
+            let value: LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZPtr = res.cOpaqueStruct!.contents
+            let a: LDKThirtyTwoBytes = value.result!.pointee.a
+            let b: LDKChannelMonitor = value.result!.pointee.b
+            let currentChannelMonitor = ChannelMonitor(pointer: b)
+            monitors.append(b)
+            self.channel_monitors.append((currentChannelMonitor, Bindings.LDKThirtyTwoBytes_to_array(nativeType: a)))
+        }
+        
+        let res = UtilMethods.constructor_BlockHashChannelManagerZ_read(ser: channel_manager_serialized, arg_keys_manager: keys_interface, arg_fee_estimator: fee_estimator, arg_chain_monitor: chain_monitor.as_Watch(), arg_tx_broadcaster: tx_broadcaster, arg_logger: logger, arg_default_config: UserConfig(), arg_channel_monitors: monitors)
+        if res.cOpaqueStruct?.result_ok != true {
+            throw InvalidSerializedDataError.runtimeError
+        }
+        let latestBlockHash = Bindings.LDKThirtyTwoBytes_to_array(nativeType: res.cOpaqueStruct!.contents.result.pointee.a)
+        let channelManager = ChannelManager(pointer: res.cOpaqueStruct!.contents.result.pointee.b)
+        
+        self.channelManager = channelManager
+        self.channel_manager_latest_block_hash = latestBlockHash
+        self.chain_monitor = chain_monitor
+        
+        if let filter = filter {
+            for (currentMonitor, _) in self.channel_monitors {
+                currentMonitor.load_outputs_to_watch(filter: filter)
+            }
+        }
+        
+    }
+    
+}

bindings/batteries/UtilMethods.swift

@@ -0,0 +1,31 @@
+//
+//  UtilMethods.swift
+//  LDKSwiftARC
+//
+//  Created by Arik Sosman on 5/19/21.
+//
+
+import Foundation
+
+class UtilMethods {
+    /**
+     * Read a C2Tuple_BlockHashChannelMonitorZ from a byte array, created by C2Tuple_BlockHashChannelMonitorZ_write
+     */
+    public class func constructor_BlockHashChannelMonitorZ_read(ser: [UInt8], arg: KeysInterface) -> Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ {
+        let ret = withUnsafePointer(to: arg.cOpaqueStruct!) { (pointer: UnsafePointer<LDKKeysInterface>) -> LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ in
+            return C2Tuple_BlockHashChannelMonitorZ_read(Bindings.new_LDKu8slice(array: ser), pointer)
+        }
+        return Result_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ(pointer: ret)
+    }
+
+    /**
+     * Read a C2Tuple_BlockHashChannelManagerZ from a byte array, created by C2Tuple_BlockHashChannelManagerZ_write
+     */
+    public class func constructor_BlockHashChannelManagerZ_read(ser: [UInt8], arg_keys_manager: KeysInterface, arg_fee_estimator: FeeEstimator, arg_chain_monitor: Watch, arg_tx_broadcaster: BroadcasterInterface, arg_logger: Logger, arg_default_config: UserConfig, arg_channel_monitors: [LDKChannelMonitor]) -> Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ {
+        
+        let args = ChannelManagerReadArgs(keys_manager: arg_keys_manager, fee_estimator: arg_fee_estimator, chain_monitor: arg_chain_monitor, tx_broadcaster: arg_tx_broadcaster, logger: arg_logger, default_config: arg_default_config, channel_monitors: arg_channel_monitors)
+        let ret = C2Tuple_BlockHashChannelManagerZ_read(Bindings.new_LDKu8slice(array: ser), args.cOpaqueStruct!)
+        
+        return Result_C2Tuple_BlockHashChannelManagerZDecodeErrorZ(pointer: ret)
+    }
+}

docs/setup.md

@@ -182,24 +182,6 @@ Instantiate it:
 let filter = MyFilter()
 ```
 
-### KeysInterface
-
-Define the subclass:
-
-```swift
-//  MyKeysInterface.swift
-
-import Foundation
-
-class MyKeysInterface: KeysInterface {
-    override func get_node_secret() -> [UInt8] {
-        return [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]
-    }
-}
-```
-
-We won't be instantiating it directly, but we will need the keys interface later on.
-
 ## Phase 2: Initializations
 
 ### ChainMonitor
@@ -225,10 +207,12 @@ let timestamp_nanos = UInt32.init(truncating: NSNumber(value: timestamp_seconds
 let keysManager = KeysManager(seed: seed, starting_time_secs: timestamp_seconds, starting_time_nanos: timestamp_nanos)
 ```
 
-We will keep needing to pass around a keysInterface instance, so let's prepare it right here:
+We will keep needing to pass around a keysInterface instance, and we will also need to 
+pass its node secret to the peer manager initialization, so let's prepare it right here:
 
 ```swift
-let keysInterface = MyKeysInterface(pointer: keysManager.as_KeysInterface().cOpaqueStruct!)
+let keysInterface = keysManager.as_KeysInterface()
+let nodeSecret = Bindings.LDKSecretKey_to_array(nativeType: keysInterface.cOpaqueStruct!.get_node_secret(keysInterface.cOpaqueStruct!.this_arg))
 ```
 
 This is a bit inelegant, but we will be providing simpler casting methods for user-provided types shortly.
@@ -299,7 +283,7 @@ And finally, let's instantiate the peer manager itself:
 ```swift
 // main context (continued)
 
-let peerManager = PeerManager(message_handler: messageHandler, our_node_secret: keysInterface.get_node_secret(), ephemeral_random_data: peerManagerSeed, logger: logger)
+let peerManager = PeerManager(message_handler: messageHandler, our_node_secret: nodeSecret, ephemeral_random_data: peerManagerSeed, logger: logger)
 ```
 
 Now, all that remains is setting up the actual syscalls that are necessary within