Merge pull request #547 from thesimplekid/update_regtest

Update regtest

crates/cdk-integration-tests/src/bin/regtest_mint.rs

@@ -3,13 +3,18 @@ use std::env;
 use anyhow::Result;
 use cdk::cdk_database::mint_memory::MintMemoryDatabase;
 use cdk_integration_tests::init_regtest::{
-    fund_ln, get_temp_dir, init_bitcoin_client, init_bitcoind, init_cln, init_cln_client, init_lnd,
-    init_lnd_client, open_channel, start_cln_mint,
+    fund_ln, get_bitcoin_dir, get_cln_dir, get_temp_dir, init_bitcoin_client, init_bitcoind,
+    init_lnd, init_lnd_client, open_channel, start_cln_mint, BITCOIN_RPC_PASS, BITCOIN_RPC_USER,
 };
 use cdk_redb::MintRedbDatabase;
 use cdk_sqlite::MintSqliteDatabase;
+use ln_regtest_rs::cln::Clnd;
+use ln_regtest_rs::ln_client::{ClnClient, LightningClient};
 use tracing_subscriber::EnvFilter;
 
+const CLN_ADDR: &str = "127.0.0.1:19846";
+const CLN_TWO_ADDR: &str = "127.0.0.1:19847";
+
 #[tokio::main]
 async fn main() -> Result<()> {
     let default_filter = "debug";
@@ -23,7 +28,6 @@ async fn main() -> Result<()> {
         default_filter, sqlx_filter, hyper_filter, h2_filter
     ));
 
-    // Parse input
     tracing_subscriber::fmt().with_env_filter(env_filter).init();
 
     let mut bitcoind = init_bitcoind();
@@ -36,19 +40,47 @@ async fn main() -> Result<()> {
     let new_add = bitcoin_client.get_new_address()?;
     bitcoin_client.generate_blocks(&new_add, 200).unwrap();
 
-    let mut clnd = init_cln();
+    let cln_one_dir = get_cln_dir("one");
+    let mut clnd = Clnd::new(
+        get_bitcoin_dir(),
+        cln_one_dir.clone(),
+        CLN_ADDR.into(),
+        BITCOIN_RPC_USER.to_string(),
+        BITCOIN_RPC_PASS.to_string(),
+    );
     clnd.start_clnd()?;
 
-    let cln_client = init_cln_client().await?;
+    let cln_client = ClnClient::new(cln_one_dir.clone(), None).await?;
+
+    cln_client.wait_chain_sync().await.unwrap();
+
+    fund_ln(&bitcoin_client, &cln_client).await.unwrap();
+
+    // Create second cln
+    let cln_two_dir = get_cln_dir("two");
+    let mut clnd_two = Clnd::new(
+        get_bitcoin_dir(),
+        cln_two_dir.clone(),
+        CLN_TWO_ADDR.into(),
+        BITCOIN_RPC_USER.to_string(),
+        BITCOIN_RPC_PASS.to_string(),
+    );
+    clnd_two.start_clnd()?;
+
+    let cln_two_client = ClnClient::new(cln_two_dir.clone(), None).await?;
+
+    cln_client.wait_chain_sync().await.unwrap();
+
+    fund_ln(&bitcoin_client, &cln_two_client).await.unwrap();
 
     let mut lnd = init_lnd().await;
     lnd.start_lnd().unwrap();
 
     let lnd_client = init_lnd_client().await.unwrap();
 
-    fund_ln(&bitcoin_client, &cln_client, &lnd_client)
-        .await
-        .unwrap();
+    lnd_client.wait_chain_sync().await.unwrap();
+
+    fund_ln(&bitcoin_client, &lnd_client).await.unwrap();
 
     open_channel(&bitcoin_client, &cln_client, &lnd_client)
         .await
@@ -59,18 +91,22 @@ async fn main() -> Result<()> {
 
     let mint_db_kind = env::var("MINT_DATABASE")?;
 
+    let temp_dir_path = get_temp_dir();
+    let db_path = get_temp_dir().join("mint");
+    let cln_path = temp_dir_path.join("one");
+
     match mint_db_kind.as_str() {
         "MEMORY" => {
-            start_cln_mint(addr, port, MintMemoryDatabase::default()).await?;
+            start_cln_mint(addr, port, MintMemoryDatabase::default(), cln_path).await?;
         }
         "SQLITE" => {
-            let sqlite_db = MintSqliteDatabase::new(&get_temp_dir().join("mint")).await?;
+            let sqlite_db = MintSqliteDatabase::new(&db_path).await?;
             sqlite_db.migrate().await;
-            start_cln_mint(addr, port, sqlite_db).await?;
+            start_cln_mint(addr, port, sqlite_db, cln_path).await?;
         }
         "REDB" => {
-            let redb_db = MintRedbDatabase::new(&get_temp_dir().join("mint")).unwrap();
-            start_cln_mint(addr, port, redb_db).await?;
+            let redb_db = MintRedbDatabase::new(&db_path).unwrap();
+            start_cln_mint(addr, port, redb_db, cln_path).await?;
         }
         _ => panic!("Unknown mint db type: {}", mint_db_kind),
     };

crates/cdk-integration-tests/src/init_regtest.rs

@@ -10,23 +10,20 @@ use cdk::nuts::{CurrencyUnit, PaymentMethod};
 use cdk_cln::Cln as CdkCln;
 use ln_regtest_rs::bitcoin_client::BitcoinClient;
 use ln_regtest_rs::bitcoind::Bitcoind;
-use ln_regtest_rs::cln::Clnd;
 use ln_regtest_rs::ln_client::{ClnClient, LightningClient, LndClient};
 use ln_regtest_rs::lnd::Lnd;
 
 use crate::init_mint::start_mint;
 
-const BITCOIND_ADDR: &str = "127.0.0.1:18443";
-const ZMQ_RAW_BLOCK: &str = "tcp://127.0.0.1:28332";
-const ZMQ_RAW_TX: &str = "tcp://127.0.0.1:28333";
-const BITCOIN_RPC_USER: &str = "testuser";
-const BITCOIN_RPC_PASS: &str = "testpass";
-const CLN_ADDR: &str = "127.0.0.1:19846";
+pub const BITCOIND_ADDR: &str = "127.0.0.1:18443";
+pub const ZMQ_RAW_BLOCK: &str = "tcp://127.0.0.1:28332";
+pub const ZMQ_RAW_TX: &str = "tcp://127.0.0.1:28333";
+pub const BITCOIN_RPC_USER: &str = "testuser";
+pub const BITCOIN_RPC_PASS: &str = "testpass";
 const LND_ADDR: &str = "0.0.0.0:18449";
 const LND_RPC_ADDR: &str = "localhost:10009";
 
 const BITCOIN_DIR: &str = "bitcoin";
-const CLN_DIR: &str = "cln";
 const LND_DIR: &str = "lnd";
 
 pub fn get_mint_addr() -> String {
@@ -79,26 +76,12 @@ pub fn init_bitcoin_client() -> Result<BitcoinClient> {
     )
 }
 
-pub fn get_cln_dir() -> PathBuf {
-    let dir = get_temp_dir().join(CLN_DIR);
+pub fn get_cln_dir(name: &str) -> PathBuf {
+    let dir = get_temp_dir().join(name);
     std::fs::create_dir_all(&dir).unwrap();
     dir
 }
 
-pub fn init_cln() -> Clnd {
-    Clnd::new(
-        get_bitcoin_dir(),
-        get_cln_dir(),
-        CLN_ADDR.to_string().parse().unwrap(),
-        BITCOIN_RPC_USER.to_string(),
-        BITCOIN_RPC_PASS.to_string(),
-    )
-}
-
-pub async fn init_cln_client() -> Result<ClnClient> {
-    ClnClient::new(get_cln_dir(), None).await
-}
-
 pub fn get_lnd_dir() -> PathBuf {
     let dir = get_temp_dir().join(LND_DIR);
     std::fs::create_dir_all(&dir).unwrap();
@@ -141,11 +124,11 @@ pub async fn create_cln_backend(cln_client: &ClnClient) -> Result<CdkCln> {
     Ok(CdkCln::new(rpc_path, fee_reserve).await?)
 }
 
-pub async fn start_cln_mint<D>(addr: &str, port: u16, database: D) -> Result<()>
+pub async fn start_cln_mint<D>(addr: &str, port: u16, database: D, dir: PathBuf) -> Result<()>
 where
     D: MintDatabase<Err = cdk_database::Error> + Send + Sync + 'static,
 {
-    let cln_client = init_cln_client().await?;
+    let cln_client = ClnClient::new(dir.clone(), None).await?;
 
     let cln_backend = create_cln_backend(&cln_client).await?;
 
@@ -176,37 +159,38 @@ where
     Ok(())
 }
 
-pub async fn fund_ln(
-    bitcoin_client: &BitcoinClient,
-    cln_client: &ClnClient,
-    lnd_client: &LndClient,
-) -> Result<()> {
-    let lnd_address = lnd_client.get_new_onchain_address().await?;
+pub async fn fund_ln<C>(bitcoin_client: &BitcoinClient, ln_client: &C) -> Result<()>
+where
+    C: LightningClient,
+{
+    let ln_address = ln_client.get_new_onchain_address().await?;
 
-    bitcoin_client.send_to_address(&lnd_address, 2_000_000)?;
+    bitcoin_client.send_to_address(&ln_address, 2_000_000)?;
 
-    let cln_address = cln_client.get_new_onchain_address().await?;
-    bitcoin_client.send_to_address(&cln_address, 2_000_000)?;
+    ln_client.wait_chain_sync().await?;
 
-    let mining_address = bitcoin_client.get_new_address()?;
-    bitcoin_client.generate_blocks(&mining_address, 200)?;
+    let mine_to_address = bitcoin_client.get_new_address()?;
+    bitcoin_client.generate_blocks(&mine_to_address, 10)?;
 
-    cln_client.wait_chain_sync().await?;
-    lnd_client.wait_chain_sync().await?;
+    ln_client.wait_chain_sync().await?;
 
     Ok(())
 }
 
-pub async fn open_channel(
+pub async fn open_channel<C1, C2>(
     bitcoin_client: &BitcoinClient,
-    cln_client: &ClnClient,
-    lnd_client: &LndClient,
-) -> Result<()> {
-    let cln_info = cln_client.get_info().await?;
+    cln_client: &C1,
+    lnd_client: &C2,
+) -> Result<()>
+where
+    C1: LightningClient,
+    C2: LightningClient,
+{
+    let cln_info = cln_client.get_connect_info().await?;
 
-    let cln_pubkey = cln_info.id;
-    let cln_address = "127.0.0.1";
-    let cln_port = 19846;
+    let cln_pubkey = cln_info.pubkey;
+    let cln_address = cln_info.address;
+    let cln_port = cln_info.port;
 
     lnd_client
         .connect_peer(cln_pubkey.to_string(), cln_address.to_string(), cln_port)

crates/cdk-integration-tests/tests/regtest.rs

@@ -15,11 +15,11 @@ use cdk::nuts::{
 use cdk::wallet::client::{HttpClient, MintConnector};
 use cdk::wallet::{Wallet, WalletSubscription};
 use cdk_integration_tests::init_regtest::{
-    get_mint_url, get_mint_ws_url, init_cln_client, init_lnd_client,
+    get_cln_dir, get_mint_url, get_mint_ws_url, init_lnd_client,
 };
 use futures::{SinkExt, StreamExt};
 use lightning_invoice::Bolt11Invoice;
-use ln_regtest_rs::ln_client::LightningClient;
+use ln_regtest_rs::ln_client::{ClnClient, LightningClient};
 use ln_regtest_rs::InvoiceStatus;
 use serde_json::json;
 use tokio::time::timeout;
@@ -328,7 +328,9 @@ async fn test_internal_payment() -> Result<()> {
         .await
         .unwrap();
 
-    let cln_client = init_cln_client().await?;
+    let cln_one_dir = get_cln_dir("one");
+    let cln_client = ClnClient::new(cln_one_dir.clone(), None).await?;
+
     let payment_hash = Bolt11Invoice::from_str(&mint_quote.request)?;
     let check_paid = cln_client
         .check_incoming_payment_status(&payment_hash.payment_hash().to_string())

misc/itests.sh

@@ -15,7 +15,8 @@ cleanup() {
     
     # Kill processes
     lncli --lnddir="$cdk_itests/lnd" --network=regtest stop
-    lightning-cli --regtest --lightning-dir="$cdk_itests/cln/" stop
+    lightning-cli --regtest --lightning-dir="$cdk_itests/one/" stop
+    lightning-cli --regtest --lightning-dir="$cdk_itests/two/" stop
     bitcoin-cli --datadir="$cdk_itests/bitcoin"  -rpcuser=testuser -rpcpassword=testpass -rpcport=18443 stop
 
     # Remove the temporary directory