Merge pull request #10 from lightningdevkit/xcode_automation

Update Xcode projects for framework building and testing

Author: arik-so

bindings/LDK/Bindings.swift

@@ -6,6 +6,9 @@
 //
 
 import Foundation
+#if canImport(os)
+    import os
+#endif
 
 public typealias LDKTransactionOutputs = LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ
 public typealias TransactionOutputs = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ
@@ -64,6 +67,9 @@ open class NativeTypeWrapper: Hashable {
 public class Bindings {
 
 	internal static var minimumPrintSeverity: PrintSeverity = .WARNING
+	#if canImport(os)
+        internal static let logger = os.Logger(subsystem: Bundle.main.bundleIdentifier!, category: "ldk")
+    #endif
 
     public enum PrintSeverity: UInt {
         case DEBUG = 0
@@ -73,7 +79,19 @@ public class Bindings {
 
     internal class func print(_ string: String, severity: PrintSeverity = .DEBUG) {
         if severity.rawValue >= Self.minimumPrintSeverity.rawValue {
-            Swift.print(string)
+            #if canImport(os)
+                if severity == Self.PrintSeverity.DEBUG {
+                    logger.debug("\(string)")
+                }else if severity == Self.PrintSeverity.WARNING {
+                    logger.warning("\(string)")
+                }else if severity == Self.PrintSeverity.ERROR {
+                    logger.error("\(string)")
+                }else {
+                    logger.log("\(string)")
+                }
+            #else
+                Swift.print(string)
+            #endif
         }
     }
 
@@ -4563,6 +4581,10 @@ withUnsafePointer(to: htlc.cOpaqueStruct!) { (htlcPointer: UnsafePointer<LDKHTLC
 			}
 		}
 	}
+	
+	public class func get_ldk_swift_bindings_version() -> String {
+        return "034c20c8e2a658f53ade8a8350a1aa5f36118992"
+    }
 
 }
 

bindings/LDK/traits/Access.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 open class Access: NativeTypeWrapper {
 
 	private static var instanceCounter: UInt = 0

bindings/LDK/traits/BaseSign.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 open class BaseSign: NativeTypeWrapper {
 
 	private static var instanceCounter: UInt = 0
@@ -25,7 +27,7 @@ open class BaseSign: NativeTypeWrapper {
 
 		func validate_holder_commitmentCallback(pointer: UnsafeRawPointer?, holder_txPointer: UnsafePointer<LDKHolderCommitmentTransaction>) -> LDKCResult_NoneNoneZ {
 			let instance: BaseSign = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "BaseSign.swift::validate_holder_commitment")
-			let holder_tx = HolderCommitmentTransaction(pointer: holder_txPointer.pointee);
+			let holder_tx = HolderCommitmentTransaction(pointer: holder_txPointer.pointee).dangle();
 
 			return instance.validate_holder_commitment(holder_tx: holder_tx).cOpaqueStruct!
 		}
@@ -38,7 +40,7 @@ open class BaseSign: NativeTypeWrapper {
 
 		func sign_counterparty_commitmentCallback(pointer: UnsafeRawPointer?, commitment_txPointer: UnsafePointer<LDKCommitmentTransaction>) -> LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
 			let instance: BaseSign = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "BaseSign.swift::sign_counterparty_commitment")
-			let commitment_tx = CommitmentTransaction(pointer: commitment_txPointer.pointee);
+			let commitment_tx = CommitmentTransaction(pointer: commitment_txPointer.pointee).dangle();
 
 			return instance.sign_counterparty_commitment(commitment_tx: commitment_tx).cOpaqueStruct!
 		}
@@ -56,7 +58,7 @@ open class BaseSign: NativeTypeWrapper {
 
 		func sign_holder_commitment_and_htlcsCallback(pointer: UnsafeRawPointer?, commitment_txPointer: UnsafePointer<LDKHolderCommitmentTransaction>) -> LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ {
 			let instance: BaseSign = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "BaseSign.swift::sign_holder_commitment_and_htlcs")
-			let commitment_tx = HolderCommitmentTransaction(pointer: commitment_txPointer.pointee);
+			let commitment_tx = HolderCommitmentTransaction(pointer: commitment_txPointer.pointee).dangle();
 
 			return instance.sign_holder_commitment_and_htlcs(commitment_tx: commitment_tx).cOpaqueStruct!
 		}
@@ -79,35 +81,35 @@ open class BaseSign: NativeTypeWrapper {
 								if let per_commitment_keyUnwrapped = per_commitment_keyPointer {
 									per_commitment_key = Bindings.tuple32_to_array(nativeType: per_commitment_keyUnwrapped.pointee)
 								}
-							let htlc = HTLCOutputInCommitment(pointer: htlcPointer.pointee);
+							let htlc = HTLCOutputInCommitment(pointer: htlcPointer.pointee).dangle();
 
 			return instance.sign_justice_revoked_htlc(justice_tx: Bindings.LDKTransaction_to_array(nativeType: justice_tx), input: input, amount: amount, per_commitment_key: per_commitment_key, htlc: htlc).cOpaqueStruct!
 		}
 
 		func sign_counterparty_htlc_transactionCallback(pointer: UnsafeRawPointer?, htlc_tx: LDKTransaction, input: uintptr_t, amount: UInt64, per_commitment_point: LDKPublicKey, htlcPointer: UnsafePointer<LDKHTLCOutputInCommitment>) -> LDKCResult_SignatureNoneZ {
 			let instance: BaseSign = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "BaseSign.swift::sign_counterparty_htlc_transaction")
-			let htlc = HTLCOutputInCommitment(pointer: htlcPointer.pointee);
+			let htlc = HTLCOutputInCommitment(pointer: htlcPointer.pointee).dangle();
 
 			return instance.sign_counterparty_htlc_transaction(htlc_tx: Bindings.LDKTransaction_to_array(nativeType: htlc_tx), input: input, amount: amount, per_commitment_point: Bindings.tuple33_to_array(nativeType: per_commitment_point.compressed_form), htlc: htlc).cOpaqueStruct!
 		}
 
 		func sign_closing_transactionCallback(pointer: UnsafeRawPointer?, closing_txPointer: UnsafePointer<LDKClosingTransaction>) -> LDKCResult_SignatureNoneZ {
 			let instance: BaseSign = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "BaseSign.swift::sign_closing_transaction")
-			let closing_tx = ClosingTransaction(pointer: closing_txPointer.pointee);
+			let closing_tx = ClosingTransaction(pointer: closing_txPointer.pointee).dangle();
 
 			return instance.sign_closing_transaction(closing_tx: closing_tx).cOpaqueStruct!
 		}
 
 		func sign_channel_announcementCallback(pointer: UnsafeRawPointer?, msgPointer: UnsafePointer<LDKUnsignedChannelAnnouncement>) -> LDKCResult_SignatureNoneZ {
 			let instance: BaseSign = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "BaseSign.swift::sign_channel_announcement")
-			let msg = UnsignedChannelAnnouncement(pointer: msgPointer.pointee);
+			let msg = UnsignedChannelAnnouncement(pointer: msgPointer.pointee).dangle();
 
 			return instance.sign_channel_announcement(msg: msg).cOpaqueStruct!
 		}
 
 		func ready_channelCallback(pointer: UnsafeMutableRawPointer?, channel_parametersPointer: UnsafePointer<LDKChannelTransactionParameters>) -> Void {
 			let instance: BaseSign = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "BaseSign.swift::ready_channel")
-			let channel_parameters = ChannelTransactionParameters(pointer: channel_parametersPointer.pointee);
+			let channel_parameters = ChannelTransactionParameters(pointer: channel_parametersPointer.pointee).dangle();
 
 			return instance.ready_channel(channel_parameters: channel_parameters)
 		}

bindings/LDK/traits/BroadcasterInterface.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 open class BroadcasterInterface: NativeTypeWrapper {
 
 	private static var instanceCounter: UInt = 0

bindings/LDK/traits/ChannelManagerPersister.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 open class ChannelManagerPersister: NativeTypeWrapper {
 
 	private static var instanceCounter: UInt = 0
@@ -13,7 +15,7 @@ open class ChannelManagerPersister: NativeTypeWrapper {
 
 		func persist_managerCallback(pointer: UnsafeRawPointer?, channel_managerPointer: UnsafePointer<LDKChannelManager>) -> LDKCResult_NoneErrorZ {
 			let instance: ChannelManagerPersister = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelManagerPersister.swift::persist_manager")
-			let channel_manager = ChannelManager(pointer: channel_managerPointer.pointee);
+			let channel_manager = ChannelManager(pointer: channel_managerPointer.pointee).dangle();
 
 			return instance.persist_manager(channel_manager: channel_manager).cOpaqueStruct!
 		}

bindings/LDK/traits/ChannelMessageHandler.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 open class ChannelMessageHandler: NativeTypeWrapper {
 
 	private static var instanceCounter: UInt = 0
@@ -13,106 +15,106 @@ open class ChannelMessageHandler: NativeTypeWrapper {
 
 		func handle_open_channelCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, their_features: LDKInitFeatures, msgPointer: UnsafePointer<LDKOpenChannel>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_open_channel")
-			let msg = OpenChannel(pointer: msgPointer.pointee);
+			let msg = OpenChannel(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_open_channel(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), their_features: InitFeatures(pointer: their_features), msg: msg)
 		}
 
 		func handle_accept_channelCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, their_features: LDKInitFeatures, msgPointer: UnsafePointer<LDKAcceptChannel>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_accept_channel")
-			let msg = AcceptChannel(pointer: msgPointer.pointee);
+			let msg = AcceptChannel(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_accept_channel(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), their_features: InitFeatures(pointer: their_features), msg: msg)
 		}
 
 		func handle_funding_createdCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKFundingCreated>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_funding_created")
-			let msg = FundingCreated(pointer: msgPointer.pointee);
+			let msg = FundingCreated(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_funding_created(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_funding_signedCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKFundingSigned>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_funding_signed")
-			let msg = FundingSigned(pointer: msgPointer.pointee);
+			let msg = FundingSigned(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_funding_signed(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_funding_lockedCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKFundingLocked>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_funding_locked")
-			let msg = FundingLocked(pointer: msgPointer.pointee);
+			let msg = FundingLocked(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_funding_locked(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_shutdownCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, their_featuresPointer: UnsafePointer<LDKInitFeatures>, msgPointer: UnsafePointer<LDKShutdown>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_shutdown")
-			let their_features = InitFeatures(pointer: their_featuresPointer.pointee);
-let msg = Shutdown(pointer: msgPointer.pointee);
+			let their_features = InitFeatures(pointer: their_featuresPointer.pointee).dangle();
+let msg = Shutdown(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_shutdown(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), their_features: their_features, msg: msg)
 		}
 
 		func handle_closing_signedCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKClosingSigned>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_closing_signed")
-			let msg = ClosingSigned(pointer: msgPointer.pointee);
+			let msg = ClosingSigned(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_closing_signed(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_update_add_htlcCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKUpdateAddHTLC>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_update_add_htlc")
-			let msg = UpdateAddHTLC(pointer: msgPointer.pointee);
+			let msg = UpdateAddHTLC(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_update_add_htlc(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_update_fulfill_htlcCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKUpdateFulfillHTLC>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_update_fulfill_htlc")
-			let msg = UpdateFulfillHTLC(pointer: msgPointer.pointee);
+			let msg = UpdateFulfillHTLC(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_update_fulfill_htlc(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_update_fail_htlcCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKUpdateFailHTLC>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_update_fail_htlc")
-			let msg = UpdateFailHTLC(pointer: msgPointer.pointee);
+			let msg = UpdateFailHTLC(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_update_fail_htlc(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_update_fail_malformed_htlcCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKUpdateFailMalformedHTLC>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_update_fail_malformed_htlc")
-			let msg = UpdateFailMalformedHTLC(pointer: msgPointer.pointee);
+			let msg = UpdateFailMalformedHTLC(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_update_fail_malformed_htlc(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_commitment_signedCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKCommitmentSigned>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_commitment_signed")
-			let msg = CommitmentSigned(pointer: msgPointer.pointee);
+			let msg = CommitmentSigned(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_commitment_signed(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_revoke_and_ackCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKRevokeAndACK>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_revoke_and_ack")
-			let msg = RevokeAndACK(pointer: msgPointer.pointee);
+			let msg = RevokeAndACK(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_revoke_and_ack(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_update_feeCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKUpdateFee>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_update_fee")
-			let msg = UpdateFee(pointer: msgPointer.pointee);
+			let msg = UpdateFee(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_update_fee(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_announcement_signaturesCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKAnnouncementSignatures>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_announcement_signatures")
-			let msg = AnnouncementSignatures(pointer: msgPointer.pointee);
+			let msg = AnnouncementSignatures(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_announcement_signatures(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
@@ -125,28 +127,28 @@ let msg = Shutdown(pointer: msgPointer.pointee);
 
 		func peer_connectedCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKInit>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::peer_connected")
-			let msg = Init(pointer: msgPointer.pointee);
+			let msg = Init(pointer: msgPointer.pointee).dangle();
 
 			return instance.peer_connected(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_channel_reestablishCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKChannelReestablish>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_channel_reestablish")
-			let msg = ChannelReestablish(pointer: msgPointer.pointee);
+			let msg = ChannelReestablish(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_channel_reestablish(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_channel_updateCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKChannelUpdate>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_channel_update")
-			let msg = ChannelUpdate(pointer: msgPointer.pointee);
+			let msg = ChannelUpdate(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_channel_update(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}
 
 		func handle_errorCallback(pointer: UnsafeRawPointer?, their_node_id: LDKPublicKey, msgPointer: UnsafePointer<LDKErrorMessage>) -> Void {
 			let instance: ChannelMessageHandler = Bindings.pointerToInstance(pointer: pointer!, sourceMarker: "ChannelMessageHandler.swift::handle_error")
-			let msg = ErrorMessage(pointer: msgPointer.pointee);
+			let msg = ErrorMessage(pointer: msgPointer.pointee).dangle();
 
 			return instance.handle_error(their_node_id: Bindings.tuple33_to_array(nativeType: their_node_id.compressed_form), msg: msg)
 		}

bindings/LDK/traits/Confirm.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 open class Confirm: NativeTypeWrapper {
 
 	private static var instanceCounter: UInt = 0

bindings/LDK/traits/CustomMessageHandler.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 open class CustomMessageHandler: NativeTypeWrapper {
 
 	private static var instanceCounter: UInt = 0

bindings/LDK/traits/CustomMessageReader.swift

@@ -1,3 +1,5 @@
+import Foundation
+
 open class CustomMessageReader: NativeTypeWrapper {
 
 	private static var instanceCounter: UInt = 0