[C#] Check in initial auto-generated C# bindings

Author: TheBlueMatt

c_sharp/src/org/ldk/enums/AccessError.cs

@@ -0,0 +1,13 @@
+namespace org { namespace ldk { namespace enums {/**
+ * An error when accessing the chain via [`Access`].
+ */
+public enum AccessError {
+	/**
+	 * The requested chain is unknown.
+	 */
+	LDKAccessError_UnknownChain,
+	/**
+	 * The requested transaction doesn't exist or hasn't confirmed.
+	 */
+	LDKAccessError_UnknownTx,
+}} } }

c_sharp/src/org/ldk/enums/COption_NoneZ.cs

@@ -0,0 +1,13 @@
+namespace org { namespace ldk { namespace enums {/**
+ * An enum which can either contain a  or not
+ */
+public enum COption_NoneZ {
+	/**
+	 * When we're in this state, this COption_NoneZ contains a
+	 */
+	LDKCOption_NoneZ_Some,
+	/**
+	 * When we're in this state, this COption_NoneZ contains nothing
+	 */
+	LDKCOption_NoneZ_None,
+}} } }

c_sharp/src/org/ldk/enums/ChannelMonitorUpdateStatus.cs

@@ -0,0 +1,84 @@
+namespace org { namespace ldk { namespace enums {/**
+ * An enum representing the status of a channel monitor update persistence.
+ */
+public enum ChannelMonitorUpdateStatus {
+	/**
+	 * The update has been durably persisted and all copies of the relevant [`ChannelMonitor`]
+	 * have been updated.
+	 * 
+	 * This includes performing any `fsync()` calls required to ensure the update is guaranteed to
+	 * be available on restart even if the application crashes.
+	 */
+	LDKChannelMonitorUpdateStatus_Completed,
+	/**
+	 * Used to indicate a temporary failure (eg connection to a watchtower or remote backup of
+	 * our state failed, but is expected to succeed at some point in the future).
+	 * 
+	 * Such a failure will \"freeze\" a channel, preventing us from revoking old states or
+	 * submitting new commitment transactions to the counterparty. Once the update(s) which failed
+	 * have been successfully applied, a [`MonitorEvent::Completed`] can be used to restore the
+	 * channel to an operational state.
+	 * 
+	 * Note that a given [`ChannelManager`] will *never* re-generate a [`ChannelMonitorUpdate`].
+	 * If you return this error you must ensure that it is written to disk safely before writing
+	 * the latest [`ChannelManager`] state, or you should return [`PermanentFailure`] instead.
+	 * 
+	 * Even when a channel has been \"frozen\", updates to the [`ChannelMonitor`] can continue to
+	 * occur (e.g. if an inbound HTLC which we forwarded was claimed upstream, resulting in us
+	 * attempting to claim it on this channel) and those updates must still be persisted.
+	 * 
+	 * No updates to the channel will be made which could invalidate other [`ChannelMonitor`]s
+	 * until a [`MonitorEvent::Completed`] is provided, even if you return no error on a later
+	 * monitor update for the same channel.
+	 * 
+	 * For deployments where a copy of ChannelMonitors and other local state are backed up in a
+	 * remote location (with local copies persisted immediately), it is anticipated that all
+	 * updates will return [`InProgress`] until the remote copies could be updated.
+	 * 
+	 * [`PermanentFailure`]: ChannelMonitorUpdateStatus::PermanentFailure
+	 * [`InProgress`]: ChannelMonitorUpdateStatus::InProgress
+	 * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+	 */
+	LDKChannelMonitorUpdateStatus_InProgress,
+	/**
+	 * Used to indicate no further channel monitor updates will be allowed (likely a disk failure
+	 * or a remote copy of this [`ChannelMonitor`] is no longer reachable and thus not updatable).
+	 * 
+	 * When this is returned, [`ChannelManager`] will force-close the channel but *not* broadcast
+	 * our current commitment transaction. This avoids a dangerous case where a local disk failure
+	 * (e.g. the Linux-default remounting of the disk as read-only) causes [`PermanentFailure`]s
+	 * for all monitor updates. If we were to broadcast our latest commitment transaction and then
+	 * restart, we could end up reading a previous [`ChannelMonitor`] and [`ChannelManager`],
+	 * revoking our now-broadcasted state before seeing it confirm and losing all our funds.
+	 * 
+	 * Note that this is somewhat of a tradeoff - if the disk is really gone and we may have lost
+	 * the data permanently, we really should broadcast immediately. If the data can be recovered
+	 * with manual intervention, we'd rather close the channel, rejecting future updates to it,
+	 * and broadcast the latest state only if we have HTLCs to claim which are timing out (which
+	 * we do as long as blocks are connected).
+	 * 
+	 * In order to broadcast the latest local commitment transaction, you'll need to call
+	 * [`ChannelMonitor::get_latest_holder_commitment_txn`] and broadcast the resulting
+	 * transactions once you've safely ensured no further channel updates can be generated by your
+	 * [`ChannelManager`].
+	 * 
+	 * Note that at least one final [`ChannelMonitorUpdate`] may still be provided, which must
+	 * still be processed by a running [`ChannelMonitor`]. This final update will mark the
+	 * [`ChannelMonitor`] as finalized, ensuring no further updates (e.g. revocation of the latest
+	 * commitment transaction) are allowed.
+	 * 
+	 * Note that even if you return a [`PermanentFailure`] due to unavailability of secondary
+	 * [`ChannelMonitor`] copies, you should still make an attempt to store the update where
+	 * possible to ensure you can claim HTLC outputs on the latest commitment transaction
+	 * broadcasted later.
+	 * 
+	 * In case of distributed watchtowers deployment, the new version must be written to disk, as
+	 * state may have been stored but rejected due to a block forcing a commitment broadcast. This
+	 * storage is used to claim outputs of rejected state confirmed onchain by another watchtower,
+	 * lagging behind on block processing.
+	 * 
+	 * [`PermanentFailure`]: ChannelMonitorUpdateStatus::PermanentFailure
+	 * [`ChannelManager`]: crate::ln::channelmanager::ChannelManager
+	 */
+	LDKChannelMonitorUpdateStatus_PermanentFailure,
+}} } }

c_sharp/src/org/ldk/enums/ConfirmationTarget.cs

@@ -0,0 +1,18 @@
+namespace org { namespace ldk { namespace enums {/**
+ * An enum that represents the speed at which we want a transaction to confirm used for feerate
+ * estimation.
+ */
+public enum ConfirmationTarget {
+	/**
+	 * We are happy with this transaction confirming slowly when feerate drops some.
+	 */
+	LDKConfirmationTarget_Background,
+	/**
+	 * We'd like this transaction to confirm without major delay, but 12-18 blocks is fine.
+	 */
+	LDKConfirmationTarget_Normal,
+	/**
+	 * We'd like this transaction to confirm in the next few blocks.
+	 */
+	LDKConfirmationTarget_HighPriority,
+}} } }

c_sharp/src/org/ldk/enums/CreationError.cs

@@ -0,0 +1,28 @@
+namespace org { namespace ldk { namespace enums {/**
+ * Errors that may occur when constructing a new `RawInvoice` or `Invoice`
+ */
+public enum CreationError {
+	/**
+	 * The supplied description string was longer than 639 __bytes__ (see [`Description::new(...)`](./struct.Description.html#method.new))
+	 */
+	LDKCreationError_DescriptionTooLong,
+	/**
+	 * The specified route has too many hops and can't be encoded
+	 */
+	LDKCreationError_RouteTooLong,
+	/**
+	 * The Unix timestamp of the supplied date is less than zero or greater than 35-bits
+	 */
+	LDKCreationError_TimestampOutOfBounds,
+	/**
+	 * The supplied millisatoshi amount was greater than the total bitcoin supply.
+	 */
+	LDKCreationError_InvalidAmount,
+	/**
+	 * Route hints were required for this invoice and were missing. Applies to
+	 * [phantom invoices].
+	 * 
+	 * [phantom invoices]: crate::utils::create_phantom_invoice
+	 */
+	LDKCreationError_MissingRouteHints,
+}} } }

c_sharp/src/org/ldk/enums/Currency.cs

@@ -0,0 +1,25 @@
+namespace org { namespace ldk { namespace enums {/**
+ * Enum representing the crypto currencies (or networks) supported by this library
+ */
+public enum Currency {
+	/**
+	 * Bitcoin mainnet
+	 */
+	LDKCurrency_Bitcoin,
+	/**
+	 * Bitcoin testnet
+	 */
+	LDKCurrency_BitcoinTestnet,
+	/**
+	 * Bitcoin regtest
+	 */
+	LDKCurrency_Regtest,
+	/**
+	 * Bitcoin simnet
+	 */
+	LDKCurrency_Simnet,
+	/**
+	 * Bitcoin signet
+	 */
+	LDKCurrency_Signet,
+}} } }

c_sharp/src/org/ldk/enums/HTLCClaim.cs

@@ -0,0 +1,25 @@
+namespace org { namespace ldk { namespace enums {/**
+ * Describes the type of HTLC claim as determined by analyzing the witness.
+ */
+public enum HTLCClaim {
+	/**
+	 * Claims an offered output on a commitment transaction through the timeout path.
+	 */
+	LDKHTLCClaim_OfferedTimeout,
+	/**
+	 * Claims an offered output on a commitment transaction through the success path.
+	 */
+	LDKHTLCClaim_OfferedPreimage,
+	/**
+	 * Claims an accepted output on a commitment transaction through the timeout path.
+	 */
+	LDKHTLCClaim_AcceptedTimeout,
+	/**
+	 * Claims an accepted output on a commitment transaction through the success path.
+	 */
+	LDKHTLCClaim_AcceptedPreimage,
+	/**
+	 * Claims an offered/accepted output on a commitment transaction through the revocation path.
+	 */
+	LDKHTLCClaim_Revocation,
+}} } }

c_sharp/src/org/ldk/enums/IOError.cs

@@ -0,0 +1,23 @@
+namespace org { namespace ldk { namespace enums {/**
+ * Represents an IO Error. Note that some information is lost in the conversion from Rust.
+ */
+public enum IOError {
+	LDKIOError_NotFound,
+	LDKIOError_PermissionDenied,
+	LDKIOError_ConnectionRefused,
+	LDKIOError_ConnectionReset,
+	LDKIOError_ConnectionAborted,
+	LDKIOError_NotConnected,
+	LDKIOError_AddrInUse,
+	LDKIOError_AddrNotAvailable,
+	LDKIOError_BrokenPipe,
+	LDKIOError_AlreadyExists,
+	LDKIOError_WouldBlock,
+	LDKIOError_InvalidInput,
+	LDKIOError_InvalidData,
+	LDKIOError_TimedOut,
+	LDKIOError_WriteZero,
+	LDKIOError_Interrupted,
+	LDKIOError_Other,
+	LDKIOError_UnexpectedEof,
+}} } }

c_sharp/src/org/ldk/enums/Level.cs

@@ -0,0 +1,29 @@
+namespace org { namespace ldk { namespace enums {/**
+ * An enum representing the available verbosity levels of the logger.
+ */
+public enum Level {
+	/**
+	 * Designates extremely verbose information, including gossip-induced messages
+	 */
+	LDKLevel_Gossip,
+	/**
+	 * Designates very low priority, often extremely verbose, information
+	 */
+	LDKLevel_Trace,
+	/**
+	 * Designates lower priority information
+	 */
+	LDKLevel_Debug,
+	/**
+	 * Designates useful information
+	 */
+	LDKLevel_Info,
+	/**
+	 * Designates hazardous situations
+	 */
+	LDKLevel_Warn,
+	/**
+	 * Designates very serious errors
+	 */
+	LDKLevel_Error,
+}} } }

c_sharp/src/org/ldk/enums/Network.cs

@@ -0,0 +1,21 @@
+namespace org { namespace ldk { namespace enums {/**
+ * An enum representing the possible Bitcoin or test networks which we can run on
+ */
+public enum Network {
+	/**
+	 * The main Bitcoin blockchain.
+	 */
+	LDKNetwork_Bitcoin,
+	/**
+	 * The testnet3 blockchain.
+	 */
+	LDKNetwork_Testnet,
+	/**
+	 * A local test blockchain.
+	 */
+	LDKNetwork_Regtest,
+	/**
+	 * A blockchain on which blocks are signed instead of mined.
+	 */
+	LDKNetwork_Signet,
+}} } }