feat: add configurable BIP39 mnemonic word counts

Support generating BIP39 mnemonics with configurable word counts (12, 15, 18, 21, 24).
Defaults to 24 words (256-bit entropy) for backward compatibility.

- Add MnemonicWordCount enum (12–24 variants)
- Update generate_entropy_mnemonic to accept optional word_count
- Map word counts to correct entropy sizes per BIP39
- Extend tests for all word count options and defaults
- Expose enum and updated function in UDL bindings

Author: coreyphillips

bindings/ldk_node.udl

@@ -1,5 +1,5 @@
 namespace ldk_node {
-	Mnemonic generate_entropy_mnemonic();
+	Mnemonic generate_entropy_mnemonic(MnemonicWordCount? word_count);
 	Config default_config();
 };
 
@@ -46,6 +46,14 @@ dictionary LSPS2ServiceConfig {
 	u64 max_payment_size_msat;
 };
 
+enum MnemonicWordCount {
+	"Words12",
+	"Words15",
+	"Words18",
+	"Words21",
+	"Words24",
+};
+
 enum LogLevel {
 	"Gossip",
 	"Trace",

src/io/utils.rs

@@ -47,23 +47,26 @@ use crate::io::{
 };
 use crate::logger::{log_error, LdkLogger, Logger};
 use crate::peer_store::PeerStore;
-use crate::types::{Broadcaster, DynStore, KeysManager, Sweeper};
+use crate::types::{Broadcaster, DynStore, KeysManager, MnemonicWordCount, Sweeper};
 use crate::wallet::ser::{ChangeSetDeserWrapper, ChangeSetSerWrapper};
 use crate::{Error, EventQueue, NodeMetrics, PaymentDetails};
 
 pub const EXTERNAL_PATHFINDING_SCORES_CACHE_KEY: &str = "external_pathfinding_scores_cache";
 
-/// Generates a random [BIP 39] mnemonic.
+/// Generates a random [BIP 39] mnemonic with the specified word count.
+///
+/// If no word count is specified, defaults to 24 words (256-bit entropy).
 ///
 /// The result may be used to initialize the [`Node`] entropy, i.e., can be given to
 /// [`Builder::set_entropy_bip39_mnemonic`].
 ///
 /// [BIP 39]: https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki
 /// [`Node`]: crate::Node
 /// [`Builder::set_entropy_bip39_mnemonic`]: crate::Builder::set_entropy_bip39_mnemonic
-pub fn generate_entropy_mnemonic() -> Mnemonic {
-	// bip39::Mnemonic supports 256 bit entropy max
-	let mut entropy = [0; 32];
+pub fn generate_entropy_mnemonic(word_count: Option<MnemonicWordCount>) -> Mnemonic {
+	let word_count = word_count.unwrap_or(MnemonicWordCount::Words24);
+	let entropy_bytes = word_count.entropy_bytes();
+	let mut entropy = vec![0u8; entropy_bytes];
 	OsRng.try_fill_bytes(&mut entropy).expect("Failed to generate entropy");
 	Mnemonic::from_entropy(&entropy).unwrap()
 }
@@ -627,9 +630,35 @@ mod tests {
 
 	#[test]
 	fn mnemonic_to_entropy_to_mnemonic() {
-		let mnemonic = generate_entropy_mnemonic();
-
+		// Test default (24 words)
+		let mnemonic = generate_entropy_mnemonic(None);
 		let entropy = mnemonic.to_entropy();
 		assert_eq!(mnemonic, Mnemonic::from_entropy(&entropy).unwrap());
+		assert_eq!(mnemonic.word_count(), 24);
+
+		// Test with different word counts
+		let word_counts = [
+			MnemonicWordCount::Words12,
+			MnemonicWordCount::Words15,
+			MnemonicWordCount::Words18,
+			MnemonicWordCount::Words21,
+			MnemonicWordCount::Words24,
+		];
+
+		for word_count in word_counts {
+			let mnemonic = generate_entropy_mnemonic(Some(word_count));
+			let entropy = mnemonic.to_entropy();
+			assert_eq!(mnemonic, Mnemonic::from_entropy(&entropy).unwrap());
+
+			// Verify expected word count
+			let expected_words = match word_count {
+				MnemonicWordCount::Words12 => 12,
+				MnemonicWordCount::Words15 => 15,
+				MnemonicWordCount::Words18 => 18,
+				MnemonicWordCount::Words21 => 21,
+				MnemonicWordCount::Words24 => 24,
+			};
+			assert_eq!(mnemonic.word_count(), expected_words);
+		}
 	}
 }

src/lib.rs

@@ -155,7 +155,8 @@ use types::{
 	OnionMessenger, PaymentStore, PeerManager, Router, Scorer, Sweeper, Wallet,
 };
 pub use types::{
-	ChannelDetails, CustomTlvRecord, DynStore, PeerDetails, SyncAndAsyncKVStore, UserChannelId,
+	ChannelDetails, CustomTlvRecord, DynStore, MnemonicWordCount, PeerDetails, SyncAndAsyncKVStore,
+	UserChannelId,
 };
 pub use {
 	bip39, bitcoin, lightning, lightning_invoice, lightning_liquidity, lightning_types, tokio,

src/types.rs

@@ -36,6 +36,34 @@ use crate::logger::Logger;
 use crate::message_handler::NodeCustomMessageHandler;
 use crate::payment::PaymentDetails;
 
+/// Supported BIP39 mnemonic word counts for entropy generation.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MnemonicWordCount {
+	/// 12-word mnemonic (128-bit entropy)
+	Words12,
+	/// 15-word mnemonic (160-bit entropy)
+	Words15,
+	/// 18-word mnemonic (192-bit entropy)
+	Words18,
+	/// 21-word mnemonic (224-bit entropy)
+	Words21,
+	/// 24-word mnemonic (256-bit entropy)
+	Words24,
+}
+
+impl MnemonicWordCount {
+	/// Returns the entropy size in bytes for the word count.
+	pub fn entropy_bytes(&self) -> usize {
+		match self {
+			MnemonicWordCount::Words12 => 16, // 128 bits
+			MnemonicWordCount::Words15 => 20, // 160 bits
+			MnemonicWordCount::Words18 => 24, // 192 bits
+			MnemonicWordCount::Words21 => 28, // 224 bits
+			MnemonicWordCount::Words24 => 32, // 256 bits
+		}
+	}
+}
+
 /// A supertrait that requires that a type implements both [`KVStore`] and [`KVStoreSync`] at the
 /// same time.
 pub trait SyncAndAsyncKVStore: KVStore + KVStoreSync {}