Update generated files to 118.

Author: arik-so

out/Bindings.swift

@@ -400,7 +400,7 @@ public class Bindings {
 		return returnValue
 	}
 
-	/// Fetches the set of [`InitFeatures`] flags which are provided by or required by
+	/// Fetches the set of [`InitFeatures`] flags that are provided by or required by
 	/// [`ChannelManager`].
 	public class func providedInitFeatures(config: UserConfig) -> InitFeatures {
 		// native call variable prep
@@ -1433,12 +1433,14 @@ public class Bindings {
 		return returnValue
 	}
 
-	/// Create an onion message with contents `message` to the destination of `path`.
-	/// Returns (introduction_node_id, onion_msg)
+	/// Creates an [`OnionMessage`] with the given `contents` for sending to the destination of
+	/// `path`.
+	///
+	/// Returns both the node id of the peer to send the message to and the message itself.
 	///
 	/// Note that reply_path (or a relevant inner pointer) may be NULL or all-0s to represent None
 	public class func createOnionMessage(
-		entropySource: EntropySource, nodeSigner: NodeSigner, path: OnionMessagePath, message: OnionMessageContents,
+		entropySource: EntropySource, nodeSigner: NodeSigner, path: OnionMessagePath, contents: OnionMessageContents,
 		replyPath: BlindedPath
 	) -> Result_C2Tuple_PublicKeyOnionMessageZSendErrorZ {
 		// native call variable prep
@@ -1453,7 +1455,7 @@ public class Bindings {
 					(nodeSignerPointer: UnsafePointer<LDKNodeSigner>) in
 					create_onion_message(
 						entropySourcePointer, nodeSignerPointer, path.dynamicallyDangledClone().cType!,
-						message.danglingClone().cType!, replyPath.dynamicallyDangledClone().cType!)
+						contents.activate().cType!, replyPath.dynamicallyDangledClone().cType!)
 				}
 
 			}
@@ -1470,6 +1472,36 @@ public class Bindings {
 		return returnValue
 	}
 
+	/// Decode one layer of an incoming [`OnionMessage`].
+	///
+	/// Returns either the next layer of the onion for forwarding or the decrypted content for the
+	/// receiver.
+	public class func peelOnionMessage(
+		msg: OnionMessage, nodeSigner: NodeSigner, logger: Logger, customHandler: CustomOnionMessageHandler
+	) -> Result_PeeledOnionNoneZ {
+		// native call variable prep
+
+
+		// native method call
+		let nativeCallResult =
+			withUnsafePointer(to: msg.cType!) { (msgPointer: UnsafePointer<LDKOnionMessage>) in
+				peel_onion_message(
+					msgPointer, nodeSigner.activate().cType!, logger.activate().cType!, customHandler.activate().cType!)
+			}
+
+
+		// cleanup
+
+
+		// return value (do some wrapping)
+		let returnValue = Result_PeeledOnionNoneZ(
+			cType: nativeCallResult, instantiationContext: "Bindings.swift::\(#function):\(#line)")
+
+
+		try! returnValue.addAnchor(anchor: msg)
+		return returnValue
+	}
+
 	/// Pays the given [`Bolt11Invoice`], retrying if needed based on [`Retry`].
 	///
 	/// [`Bolt11Invoice::payment_hash`] is used as the [`PaymentId`], which ensures idempotency as long

out/VersionDescriptor.swift

@@ -4,12 +4,12 @@
 
 extension Bindings {
 	public class func getLDKSwiftBindingsSerializationHash() -> String {
-		return "3306eaf9d996970e7040eebe5287b47dc30e5a5e64ae7cd1460768ad62f00a75"
+		return "f648b3a8393e53cb007c6b2d58df2e242a376535e61e428e2994b1f5a137bda7"
 	}
 	public class func getLDKSwiftBindingsVersion() -> String {
-		return "0.0.116-7-ga0e95f8d-dirty"
+		return "0.0.116-24-gf0a2c328-dirty"
 	}
 	public class func getLDKSwiftBindingsCommitHash() -> String {
-		return "a0e95f8d512595f491c48d3860397f7b52be7e4d"
+		return "f0a2c3287f3f8c0061c11c373bbbded2e6cc1009"
 	}
 }

out/enums/complex/BumpTransactionEvent.swift

@@ -132,7 +132,6 @@ extension Bindings {
 			///
 			/// [`EcdsaChannelSigner`]: crate::sign::EcdsaChannelSigner
 			/// [`EcdsaChannelSigner::sign_holder_htlc_transaction`]: crate::sign::EcdsaChannelSigner::sign_holder_htlc_transaction
-			/// [`HTLCDescriptor::tx_input_witness`]: HTLCDescriptor::tx_input_witness
 			case HTLCResolution
 
 		}

out/enums/complex/Event.swift

@@ -125,6 +125,16 @@ extension Bindings {
 			/// [`ChannelManager::claim_funds`]: crate::ln::channelmanager::ChannelManager::claim_funds
 			case PaymentClaimed
 
+			/// Indicates a request for an invoice failed to yield a response in a reasonable amount of time
+			/// or was explicitly abandoned by [`ChannelManager::abandon_payment`]. This may be for an
+			/// [`InvoiceRequest`] sent for an [`Offer`] or for a [`Refund`] that hasn't been redeemed.
+			///
+			/// [`ChannelManager::abandon_payment`]: crate::ln::channelmanager::ChannelManager::abandon_payment
+			/// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
+			/// [`Offer`]: crate::offers::offer::Offer
+			/// [`Refund`]: crate::offers::refund::Refund
+			case InvoiceRequestFailed
+
 			/// Indicates an outbound payment we made succeeded (i.e. it made it all the way to its target
 			/// and we got back the payment preimage for it).
 			///
@@ -285,6 +295,9 @@ extension Bindings {
 				case LDKEvent_PaymentClaimed:
 					return .PaymentClaimed
 
+				case LDKEvent_InvoiceRequestFailed:
+					return .InvoiceRequestFailed
+
 				case LDKEvent_PaymentSent:
 					return .PaymentSent
 
@@ -530,6 +543,30 @@ extension Bindings {
 			return returnValue
 		}
 
+		/// Utility method to constructs a new InvoiceRequestFailed-variant Event
+		public class func initWithInvoiceRequestFailed(paymentId: [UInt8]) -> Event {
+			// native call variable prep
+
+			let paymentIdPrimitiveWrapper = ThirtyTwoBytes(
+				value: paymentId, instantiationContext: "Event.swift::\(#function):\(#line)")
+
+
+			// native method call
+			let nativeCallResult = Event_invoice_request_failed(paymentIdPrimitiveWrapper.cType!)
+
+			// cleanup
+
+			// for elided types, we need this
+			paymentIdPrimitiveWrapper.noOpRetain()
+
+
+			// return value (do some wrapping)
+			let returnValue = Event(cType: nativeCallResult, instantiationContext: "Event.swift::\(#function):\(#line)")
+
+
+			return returnValue
+		}
+
 		/// Utility method to constructs a new PaymentSent-variant Event
 		public class func initWithPaymentSent(
 			paymentId: [UInt8]?, paymentPreimage: [UInt8], paymentHash: [UInt8], feePaidMsat: UInt64?
@@ -1236,6 +1273,16 @@ extension Bindings {
 				anchor: self)
 		}
 
+		public func getValueAsInvoiceRequestFailed() -> InvoiceRequestFailed? {
+			if self.cType?.tag != LDKEvent_InvoiceRequestFailed {
+				return nil
+			}
+
+			return Event_LDKInvoiceRequestFailed_Body(
+				cType: self.cType!.invoice_request_failed, instantiationContext: "Event.swift::\(#function):\(#line)",
+				anchor: self)
+		}
+
 		public func getValueAsPaymentSent() -> PaymentSent? {
 			if self.cType?.tag != LDKEvent_PaymentSent {
 				return nil
@@ -1889,6 +1936,78 @@ extension Bindings {
 		}
 
 
+		///
+		internal typealias Event_LDKInvoiceRequestFailed_Body = InvoiceRequestFailed
+
+
+		///
+		public class InvoiceRequestFailed: NativeTypeWrapper {
+
+
+			/// Set to false to suppress an individual type's deinit log statements.
+			/// Only applicable when log threshold is set to `.Debug`.
+			public static var enableDeinitLogging = true
+
+			/// Set to true to suspend the freeing of this type's associated Rust memory.
+			/// Should only ever be used for debugging purposes, and will likely be
+			/// deprecated soon.
+			public static var suspendFreedom = false
+
+			private static var instanceCounter: UInt = 0
+			internal let instanceNumber: UInt
+
+			internal var cType: LDKEvent_LDKInvoiceRequestFailed_Body?
+
+			internal init(cType: LDKEvent_LDKInvoiceRequestFailed_Body, instantiationContext: String) {
+				Self.instanceCounter += 1
+				self.instanceNumber = Self.instanceCounter
+				self.cType = cType
+
+				super.init(conflictAvoidingVariableName: 0, instantiationContext: instantiationContext)
+			}
+
+			internal init(
+				cType: LDKEvent_LDKInvoiceRequestFailed_Body, instantiationContext: String, anchor: NativeTypeWrapper
+			) {
+				Self.instanceCounter += 1
+				self.instanceNumber = Self.instanceCounter
+				self.cType = cType
+
+				super.init(conflictAvoidingVariableName: 0, instantiationContext: instantiationContext)
+				self.dangling = true
+				try! self.addAnchor(anchor: anchor)
+			}
+
+			internal init(
+				cType: LDKEvent_LDKInvoiceRequestFailed_Body, instantiationContext: String, anchor: NativeTypeWrapper,
+				dangle: Bool = false
+			) {
+				Self.instanceCounter += 1
+				self.instanceNumber = Self.instanceCounter
+				self.cType = cType
+
+				super.init(conflictAvoidingVariableName: 0, instantiationContext: instantiationContext)
+				self.dangling = dangle
+				try! self.addAnchor(anchor: anchor)
+			}
+
+
+			/// The `payment_id` to have been associated with payment for the requested invoice.
+			public func getPaymentId() -> [UInt8] {
+				// return value (do some wrapping)
+				let returnValue = ThirtyTwoBytes(
+					cType: self.cType!.payment_id, instantiationContext: "Event.swift::\(#function):\(#line)",
+					anchor: self
+				)
+				.getValue()
+
+				return returnValue
+			}
+
+
+		}
+
+
 		///
 		internal typealias Event_LDKPaymentSent_Body = PaymentSent
 

out/enums/complex/OffersMessage.swift

@@ -213,28 +213,6 @@ extension Bindings {
 			return returnValue
 		}
 
-		/// The TLV record type for the message as used in an `onionmsg_tlv` TLV stream.
-		public func tlvType() -> UInt64 {
-			// native call variable prep
-
-
-			// native method call
-			let nativeCallResult =
-				withUnsafePointer(to: self.cType!) { (thisArgPointer: UnsafePointer<LDKOffersMessage>) in
-					OffersMessage_tlv_type(thisArgPointer)
-				}
-
-
-			// cleanup
-
-
-			// return value (do some wrapping)
-			let returnValue = nativeCallResult
-
-
-			return returnValue
-		}
-
 		/// Serialize the OffersMessage object into a byte array which can be read by OffersMessage_read
 		public func write() -> [UInt8] {
 			// native call variable prep