ldk_node.udl

namespace ldk_node {
	Mnemonic generate_entropy_mnemonic();
};

dictionary Config {
	string storage_dir_path = "/tmp/ldk_node/";
	string? log_dir_path = null;
	Network network = "Bitcoin";
	sequence<SocketAddress>? listening_addresses = null;
	u32 default_cltv_expiry_delta = 144;
	u64 onchain_wallet_sync_interval_secs = 80;
	u64 wallet_sync_interval_secs = 30;
	u64 fee_rate_cache_update_interval_secs = 600;
	sequence<PublicKey> trusted_peers_0conf = [];
	u64 probing_liquidity_limit_multiplier = 3;
	LogLevel log_level = "Debug";
};

interface Builder {
	constructor();
	[Name=from_config]
	constructor(Config config);
	void set_entropy_seed_path(string seed_path);
	[Throws=BuildError]
	void set_entropy_seed_bytes(sequence<u8> seed_bytes);
	void set_entropy_bip39_mnemonic(Mnemonic mnemonic, string? passphrase);
	void set_esplora_server(string esplora_server_url);
	void set_gossip_source_p2p();
	void set_gossip_source_rgs(string rgs_server_url);
	void set_storage_dir_path(string storage_dir_path);
	void set_network(Network network);
	[Throws=BuildError]
	void set_listening_addresses(sequence<SocketAddress> listening_addresses);
	[Throws=BuildError]
	LDKNode build();
};

interface LDKNode {
	[Throws=NodeError]
	void start();
	[Throws=NodeError]
	void stop();
	Event? next_event();
	Event wait_next_event();
	void event_handled();
	PublicKey node_id();
	sequence<SocketAddress>? listening_addresses();
	[Throws=NodeError]
	Address new_onchain_address();
	[Throws=NodeError]
	Txid send_to_onchain_address([ByRef]Address address, u64 amount_msat);
	[Throws=NodeError]
	Txid send_all_to_onchain_address([ByRef]Address address);
	[Throws=NodeError]
	u64 spendable_onchain_balance_sats();
	[Throws=NodeError]
	u64 total_onchain_balance_sats();
	[Throws=NodeError]
	void connect(PublicKey node_id, SocketAddress address, boolean persist);
	[Throws=NodeError]
	void disconnect(PublicKey node_id);
	[Throws=NodeError]
	void connect_open_channel(PublicKey node_id, SocketAddress address, u64 channel_amount_sats, u64? push_to_counterparty_msat, ChannelConfig? channel_config, boolean announce_channel);
	[Throws=NodeError]
	void close_channel([ByRef]ChannelId channel_id, PublicKey counterparty_node_id);
	[Throws=NodeError]
	void update_channel_config([ByRef]ChannelId channel_id, PublicKey counterparty_node_id, ChannelConfig channel_config);
	[Throws=NodeError]
	void sync_wallets();
	[Throws=NodeError]
	PaymentHash send_payment([ByRef]Bolt11Invoice invoice);
	[Throws=NodeError]
	PaymentHash send_payment_using_amount([ByRef]Bolt11Invoice invoice, u64 amount_msat);
	[Throws=NodeError]
	PaymentHash send_spontaneous_payment(u64 amount_msat, PublicKey node_id);
	[Throws=NodeError]
	void send_payment_probes([ByRef]Bolt11Invoice invoice);
	[Throws=NodeError]
	void send_spontaneous_payment_probes(u64 amount_msat, PublicKey node_id);
	[Throws=NodeError]
	void send_payment_probes_using_amount([ByRef]Bolt11Invoice invoice, u64 amount_msat);
	[Throws=NodeError]
	Bolt11Invoice receive_payment(u64 amount_msat, [ByRef]string description, u32 expiry_secs);
	[Throws=NodeError]
	Bolt11Invoice receive_variable_amount_payment([ByRef]string description, u32 expiry_secs);
	PaymentDetails? payment([ByRef]PaymentHash payment_hash);
	[Throws=NodeError]
	void remove_payment([ByRef]PaymentHash payment_hash);
	sequence<PaymentDetails> list_payments();
	sequence<PeerDetails> list_peers();
	sequence<ChannelDetails> list_channels();
	[Throws=NodeError]
	string sign_message([ByRef]sequence<u8> msg);
	boolean verify_signature([ByRef]sequence<u8> msg, [ByRef]string sig, [ByRef]PublicKey pkey);
	boolean is_running();
};

[Error]
enum NodeError {
	"AlreadyRunning",
	"NotRunning",
	"OnchainTxCreationFailed",
	"ConnectionFailed",
	"InvoiceCreationFailed",
	"PaymentSendingFailed",
	"ProbeSendingFailed",
	"ChannelCreationFailed",
	"ChannelClosingFailed",
	"ChannelConfigUpdateFailed",
	"PersistenceFailed",
	"FeerateEstimationUpdateFailed",
	"WalletOperationFailed",
	"OnchainTxSigningFailed",
	"MessageSigningFailed",
	"TxSyncFailed",
	"GossipUpdateFailed",
	"InvalidAddress",
	"InvalidSocketAddress",
	"InvalidPublicKey",
	"InvalidSecretKey",
	"InvalidPaymentHash",
	"InvalidPaymentPreimage",
	"InvalidPaymentSecret",
	"InvalidAmount",
	"InvalidInvoice",
	"InvalidChannelId",
	"InvalidNetwork",
	"DuplicatePayment",
	"InsufficientFunds",
};

[Error]
enum BuildError {
	"InvalidSeedBytes",
	"InvalidSeedFile",
	"InvalidSystemTime",
	"InvalidChannelMonitor",
	"InvalidListeningAddresses",
	"ReadFailed",
	"WriteFailed",
	"StoragePathAccessFailed",
	"KVStoreSetupFailed",
	"WalletSetupFailed",
	"LoggerSetupFailed",
};

[Enum]
interface Event {
	PaymentSuccessful( PaymentHash payment_hash );
	PaymentFailed( PaymentHash payment_hash );
	PaymentReceived( PaymentHash payment_hash, u64 amount_msat);
	ChannelPending ( ChannelId channel_id, UserChannelId user_channel_id, ChannelId former_temporary_channel_id, PublicKey counterparty_node_id, OutPoint funding_txo );
	ChannelReady ( ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id );
	ChannelClosed ( ChannelId channel_id, UserChannelId user_channel_id, PublicKey? counterparty_node_id );
};

enum PaymentDirection {
	"Inbound",
	"Outbound",
};

enum PaymentStatus {
	"Pending",
	"Succeeded",
	"Failed",
};

enum Network {
	"Bitcoin",
	"Testnet",
	"Signet",
	"Regtest",
};

dictionary PaymentDetails {
	PaymentHash hash;
	PaymentPreimage? preimage;
	PaymentSecret? secret;
	u64? amount_msat;
	PaymentDirection direction;
	PaymentStatus status;
};

dictionary OutPoint {
	Txid txid;
	u32 vout;
};

dictionary ChannelDetails {
	ChannelId channel_id;
	PublicKey counterparty_node_id;
	OutPoint? funding_txo;
	u64 channel_value_sats;
	u64? unspendable_punishment_reserve;
	UserChannelId user_channel_id;
	u32 feerate_sat_per_1000_weight;
	u64 balance_msat;
	u64 outbound_capacity_msat;
	u64 inbound_capacity_msat;
	u32? confirmations_required;
	u32? confirmations;
	boolean is_outbound;
	boolean is_channel_ready;
	boolean is_usable;
	boolean is_public;
	u16? cltv_expiry_delta;
	u64 counterparty_unspendable_punishment_reserve;
	u64? counterparty_outbound_htlc_minimum_msat;
	u64? counterparty_outbound_htlc_maximum_msat;
	u32? counterparty_forwarding_info_fee_base_msat;
	u32? counterparty_forwarding_info_fee_proportional_millionths;
	u16? counterparty_forwarding_info_cltv_expiry_delta;
	u64 next_outbound_htlc_limit_msat;
	u64 next_outbound_htlc_minimum_msat;
	u16? force_close_spend_delay;
	u64 inbound_htlc_minimum_msat;
	u64? inbound_htlc_maximum_msat;
	ChannelConfig config;
};

dictionary PeerDetails {
	PublicKey node_id;
	SocketAddress address;
	boolean is_persisted;
	boolean is_connected;
};

interface ChannelConfig {
	constructor();
	u32 forwarding_fee_proportional_millionths();
	void set_forwarding_fee_proportional_millionths(u32 value);
	u32 forwarding_fee_base_msat();
	void set_forwarding_fee_base_msat(u32 fee_msat);
	u16 cltv_expiry_delta();
	void set_cltv_expiry_delta(u16 value);
	u64 force_close_avoidance_max_fee_satoshis();
	void set_force_close_avoidance_max_fee_satoshis(u64 value_sat);
	boolean accept_underpaying_htlcs();
	void set_accept_underpaying_htlcs(boolean value);
	void set_max_dust_htlc_exposure_from_fixed_limit(u64 limit_msat);
	void set_max_dust_htlc_exposure_from_fee_rate_multiplier(u64 multiplier);
};

enum LogLevel {
	"Gossip",
	"Trace",
	"Debug",
	"Info",
	"Warn",
	"Error",
};

[Custom]
typedef string Txid;

[Custom]
typedef string SocketAddress;

[Custom]
typedef string PublicKey;

[Custom]
typedef string Address;

[Custom]
typedef string Bolt11Invoice;

[Custom]
typedef string PaymentHash;

[Custom]
typedef string PaymentPreimage;

[Custom]
typedef string PaymentSecret;

[Custom]
typedef string ChannelId;

[Custom]
typedef string UserChannelId;

[Custom]
typedef string Mnemonic;