f Re-introduce Network newtype

... as `bitcoin::Network` is now `non_exhaustive`.

README.md

@@ -11,11 +11,10 @@ LDK Node is a self-custodial Lightning node in library form. Its central goal is
 The primary abstraction of the library is the [`Node`][api_docs_node], which can be retrieved by setting up and configuring a [`Builder`][api_docs_builder] to your liking and calling one of the `build` methods. `Node` can then be controlled via commands such as `start`, `stop`, `connect_open_channel`, `send_payment`, etc.
 
 ```rust
-use ldk_node::Builder;
+use ldk_node::{Builder, Network};
 use ldk_node::lightning_invoice::Invoice;
 use ldk_node::lightning::ln::msgs::SocketAddress;
 use ldk_node::bitcoin::secp256k1::PublicKey;
-use ldk_node::bitcoin::Network;
 use std::str::FromStr;
 
 fn main() {

src/builder.rs

@@ -9,8 +9,8 @@ use crate::peer_store::PeerStore;
 use crate::sweep::OutputSweeper;
 use crate::tx_broadcaster::TransactionBroadcaster;
 use crate::types::{
-	ChainMonitor, ChannelManager, FakeMessageRouter, GossipSync, KeysManager, NetworkGraph,
-	OnionMessenger, PeerManager,
+	ChainMonitor, ChannelManager, FakeMessageRouter, GossipSync, KeysManager, Network,
+	NetworkGraph, OnionMessenger, PeerManager,
 };
 use crate::wallet::Wallet;
 use crate::LogLevel;
@@ -47,8 +47,6 @@ use bdk::blockchain::esplora::EsploraBlockchain;
 use bdk::database::SqliteDatabase;
 use bdk::template::Bip84;
 
-use bitcoin::Network;
-
 use bip39::Mnemonic;
 
 use bitcoin::BlockHash;
@@ -436,16 +434,16 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 	logger: Arc<FilesystemLogger>, kv_store: Arc<K>,
 ) -> Result<Node<K>, BuildError> {
 	// Initialize the on-chain wallet and chain access
-	let xprv =
-		bitcoin::bip32::ExtendedPrivKey::new_master(config.network, &seed_bytes).map_err(|e| {
+	let xprv = bitcoin::bip32::ExtendedPrivKey::new_master(config.network.into(), &seed_bytes)
+		.map_err(|e| {
 			log_error!(logger, "Failed to derive master secret: {}", e);
 			BuildError::InvalidSeedBytes
 		})?;
 
 	let wallet_name = bdk::wallet::wallet_name_from_descriptor(
 		Bip84(xprv, bdk::KeychainKind::External),
 		Some(Bip84(xprv, bdk::KeychainKind::Internal)),
-		config.network,
+		config.network.into(),
 		&Secp256k1::new(),
 	)
 	.map_err(|e| {
@@ -459,7 +457,7 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 	let bdk_wallet = bdk::Wallet::new(
 		Bip84(xprv, bdk::KeychainKind::External),
 		Some(Bip84(xprv, bdk::KeychainKind::Internal)),
-		config.network,
+		config.network.into(),
 		database,
 	)
 	.map_err(|e| {
@@ -537,7 +535,7 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 			Ok(graph) => Arc::new(graph),
 			Err(e) => {
 				if e.kind() == std::io::ErrorKind::NotFound {
-					Arc::new(NetworkGraph::new(config.network, Arc::clone(&logger)))
+					Arc::new(NetworkGraph::new(config.network.into(), Arc::clone(&logger)))
 				} else {
 					return Err(BuildError::ReadFailed);
 				}
@@ -629,10 +627,10 @@ fn build_with_store_internal<K: KVStore + Sync + Send + 'static>(
 		} else {
 			// We're starting a fresh node.
 			let genesis_block_hash =
-				bitcoin::blockdata::constants::genesis_block(config.network).block_hash();
+				bitcoin::blockdata::constants::genesis_block(config.network.into()).block_hash();
 
 			let chain_params = ChainParameters {
-				network: config.network,
+				network: config.network.into(),
 				best_block: BestBlock::new(genesis_block_hash, 0),
 			};
 			channelmanager::ChannelManager::new(

src/lib.rs

@@ -26,11 +26,10 @@
 //! [`send_payment`], etc.:
 //!
 //! ```no_run
-//! use ldk_node::Builder;
+//! use ldk_node::{Builder, Network};
 //! use ldk_node::lightning_invoice::Bolt11Invoice;
 //! use ldk_node::lightning::ln::msgs::SocketAddress;
 //! use ldk_node::bitcoin::secp256k1::PublicKey;
-//! use ldk_node::bitcoin::Network;
 //! use std::str::FromStr;
 //!
 //! fn main() {
@@ -125,7 +124,7 @@ use types::{
 	Broadcaster, ChainMonitor, ChannelManager, FeeEstimator, KeysManager, NetworkGraph,
 	PeerManager, Router, Scorer, Sweeper, Wallet,
 };
-pub use types::{ChannelDetails, PeerDetails, UserChannelId};
+pub use types::{ChannelDetails, Network, PeerDetails, UserChannelId};
 
 use logger::{log_error, log_info, log_trace, FilesystemLogger, Logger};
 
@@ -150,7 +149,6 @@ use lightning_invoice::{payment, Bolt11Invoice, Currency};
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::PublicKey;
-use bitcoin::Network;
 
 use bitcoin::{Address, Txid};
 
@@ -1498,7 +1496,7 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 	fn receive_payment_inner(
 		&self, amount_msat: Option<u64>, description: &str, expiry_secs: u32,
 	) -> Result<Bolt11Invoice, Error> {
-		let currency = Currency::from(self.config.network);
+		let currency = Currency::from(bitcoin::Network::from(self.config.network));
 		let keys_manager = Arc::clone(&self.keys_manager);
 		let invoice = match lightning_invoice::utils::create_invoice_from_channelmanager(
 			&self.channel_manager,
@@ -1551,8 +1549,7 @@ impl<K: KVStore + Sync + Send + 'static> Node<K> {
 	///
 	/// For example, you could retrieve all stored outbound payments as follows:
 	/// ```
-	/// # use ldk_node::{Builder, Config, PaymentDirection};
-	/// # use ldk_node::bitcoin::Network;
+	/// # use ldk_node::{Builder, Config, Network, PaymentDirection};
 	/// # let mut config = Config::default();
 	/// # config.network = Network::Regtest;
 	/// # config.storage_dir_path = "/tmp/ldk_node_test/".to_string();

src/test/functional_tests.rs

@@ -2,7 +2,7 @@ use crate::builder::NodeBuilder;
 use crate::io::test_utils::TestSyncStore;
 use crate::test::utils::*;
 use crate::test::utils::{expect_channel_pending_event, expect_event, open_channel, random_config};
-use crate::{Error, Event, Node, PaymentDirection, PaymentStatus};
+use crate::{Error, Event, Network, Node, PaymentDirection, PaymentStatus};
 
 use bitcoin::Amount;
 use electrsd::bitcoind::BitcoinD;
@@ -409,7 +409,7 @@ fn multi_hop_sending() {
 #[test]
 fn connect_to_public_testnet_esplora() {
 	let mut config = random_config();
-	config.network = bitcoin::Network::Testnet;
+	config.network = Network::Testnet;
 	let mut builder = NodeBuilder::from_config(config);
 	builder.set_esplora_server("https://blockstream.info/testnet/api".to_string());
 	let node = builder.build().unwrap();

src/test/utils.rs

@@ -1,11 +1,11 @@
 use crate::builder::NodeBuilder;
 use crate::io::test_utils::TestSyncStore;
-use crate::{Config, Event, Node};
+use crate::{Config, Event, Network, Node};
 use lightning::ln::msgs::SocketAddress;
 use lightning::util::logger::{Level, Logger, Record};
 use lightning::util::persist::KVStore;
 
-use bitcoin::{Address, Amount, Network, OutPoint, Txid};
+use bitcoin::{Address, Amount, OutPoint, Txid};
 
 use bitcoind::bitcoincore_rpc::RpcApi;
 use electrsd::bitcoind::bitcoincore_rpc::bitcoincore_rpc_json::AddressType;
@@ -239,7 +239,7 @@ pub fn generate_blocks_and_wait(bitcoind: &BitcoinD, electrsd: &ElectrsD, num: u
 		.client
 		.get_new_address(Some("test"), Some(AddressType::Legacy))
 		.expect("failed to get new address")
-		.require_network(Network::Regtest)
+		.require_network(bitcoin::Network::Regtest)
 		.expect("failed to get new address");
 	// TODO: expect this Result once the WouldBlock issue is resolved upstream.
 	let _block_hashes_res = bitcoind.client.generate_to_address(num as u64, &address);

src/types.rs

@@ -21,6 +21,8 @@ use lightning_transaction_sync::EsploraSyncClient;
 use bitcoin::secp256k1::{self, PublicKey, Secp256k1};
 use bitcoin::OutPoint;
 
+use std::fmt;
+use std::str::FromStr;
 use std::sync::{Arc, Mutex, RwLock};
 
 pub(crate) type ChainMonitor<K> = chainmonitor::ChainMonitor<
@@ -137,6 +139,58 @@ pub(crate) type Sweeper<K> = OutputSweeper<
 	Arc<FilesystemLogger>,
 >;
 
+/// The cryptocurrency network to act on.
+#[derive(Copy, PartialEq, Eq, PartialOrd, Ord, Clone, Hash, Debug)]
+pub enum Network {
+	/// Mainnet Bitcoin.
+	Bitcoin,
+	/// Bitcoin's testnet network.
+	Testnet,
+	/// Bitcoin's signet network.
+	Signet,
+	/// Bitcoin's regtest network.
+	Regtest,
+}
+
+impl TryFrom<bitcoin::Network> for Network {
+	type Error = ();
+
+	fn try_from(network: bitcoin::Network) -> Result<Self, Self::Error> {
+		match network {
+			bitcoin::Network::Bitcoin => Ok(Self::Bitcoin),
+			bitcoin::Network::Testnet => Ok(Self::Testnet),
+			bitcoin::Network::Signet => Ok(Self::Signet),
+			bitcoin::Network::Regtest => Ok(Self::Regtest),
+			_ => Err(()),
+		}
+	}
+}
+
+impl From<Network> for bitcoin::Network {
+	fn from(network: Network) -> Self {
+		match network {
+			Network::Bitcoin => bitcoin::Network::Bitcoin,
+			Network::Testnet => bitcoin::Network::Testnet,
+			Network::Signet => bitcoin::Network::Signet,
+			Network::Regtest => bitcoin::Network::Regtest,
+		}
+	}
+}
+
+impl fmt::Display for Network {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		bitcoin::Network::from(*self).fmt(f)
+	}
+}
+
+impl FromStr for Network {
+	type Err = ();
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		bitcoin::Network::from_str(s).map_err(|_| ())?.try_into()
+	}
+}
+
 /// A local, potentially user-provided, identifier of a channel.
 ///
 /// By default, this will be randomly generated for the user to ensure local uniqueness.

tests/common.rs

@@ -1,10 +1,10 @@
 #![cfg(cln_test)]
 
-use ldk_node::{Config, LogLevel};
+use ldk_node::{Config, LogLevel, Network};
 
 use lightning::ln::msgs::SocketAddress;
 
-use bitcoin::{Address, Amount, Network, OutPoint, Txid};
+use bitcoin::{Address, Amount, OutPoint, Txid};
 
 use bitcoincore_rpc::bitcoincore_rpc_json::AddressType;
 use bitcoincore_rpc::Client as BitcoindClient;
@@ -126,7 +126,7 @@ pub(crate) fn generate_blocks_and_wait(
 	let address = bitcoind
 		.get_new_address(Some("test"), Some(AddressType::Legacy))
 		.expect("failed to get new address")
-		.require_network(Network::Regtest)
+		.require_network(bitcoin::Network::Regtest)
 		.expect("failed to get new address");
 	// TODO: expect this Result once the WouldBlock issue is resolved upstream.
 	let _block_hashes_res = bitcoind.generate_to_address(num as u64, &address);