GlcoinCore/lndk
1
0
Fork 0
mirror of https://github.com/lndk-org/lndk.git synced 2026-08-13 12:33:05 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

tests: Add integration test for check pay offer

Browse source 
This commit adds an integration test for checking the pay offer
feature using 3 available blinded paths, which nodes support onion messages
and are connected to more channels.
This commit is contained in:
f3r10 2025-09-22 13:00:04 -05:00 • committed by Maurice
parent b4cbe4e770
commit ad575148df
No known key found for this signature in database
GPG key ID: 500BD1099EBC3D61
1 changed files with 211 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

211
tests/integration_tests.rs
View file

@ -1122,6 +1122,217 @@ async fn test_receive_payment_from_offer() {
assert!(offer.is_ok());
let offer = offer.unwrap();
// we check that according the current topology, it is only one blinded path available
assert!(offer.paths().len() == 1);
select! {
val = messenger.run(lndk_cfg, Arc::clone(&handler)) => {
panic!("lndk should not have completed first {:?}", val);
},
res = pay_offer_and_wait_for_payment(&ldk1, offer, lnd.client.clone().unwrap()) => {
log::info!("res: {:?}", res);
assert!(res.is_ok());
shutdown.trigger();
ldk1.stop().await;
ldk2.stop().await;
}
};
}
#[tokio::test(flavor = "multi_thread")]
// Test that we can receive a payment from an offer which constains multiple paths.
async fn test_receive_payment_from_offer_with_multiple_blinded_paths() {
let test_name = "test_receive_payment_from_offer_with_multiple_blinded_paths";
let (bitcoind, mut lnd, ldk1, ldk2, lndk_dir, ldk_test_dir) =
common::setup_test_infrastructure(test_name).await;
let (ldk1_pubkey, ldk2_pubkey, _lnd_pubkey) =
common::connect_network(&ldk1, &ldk2, true, true, &mut lnd, &bitcoind).await;
let log_file = Some(lndk_dir.join(format!("lndk-logs.txt")));
setup_logger(None, log_file).unwrap();
// Network topology with 4 LDK nodes and 1 LND node:
//
// LDK2 ────────────────────LND
// / | \ /|\
// / | \ / | \
// LDK1 | LDK3 ─────────────── | \
// | / | \
// | / | \
// LDK4 ────────────────────────────
// Second blinded path.
let ldk3 = common::setup_ldk_node(&bitcoind, 3, &ldk_test_dir, test_name).await;
// Third blinded path.
let ldk4 = common::setup_ldk_node(&bitcoind, 4, &ldk_test_dir, test_name).await;
let (ldk3_pubkey, addr_3) = ldk3.get_node_info();
let (ldk4_pubkey, addr_4) = ldk4.get_node_info();
let (_, addr_2) = ldk2.get_node_info();
let lnd_info = lnd.get_info().await;
let lnd_pubkey = PublicKey::from_str(&lnd_info.identity_pubkey).unwrap();
lnd.connect_to_peer(ldk3_pubkey, addr_3).await;
lnd.connect_to_peer(ldk4_pubkey, addr_4).await;
ldk2.connect_to_peer(ldk4_pubkey, addr_4).await.unwrap();
ldk2.connect_to_peer(ldk3_pubkey, addr_3).await.unwrap();
let ldk3_fund_addr = ldk3.bitcoind_client.get_new_address().await;
let ldk3_addr_string = ldk3_fund_addr.to_string();
let ldk3_addr = bitcoincore_rpc::bitcoin::Address::from_str(&ldk3_addr_string)
.unwrap()
.require_network(bitcoincore_rpc::bitcoin::Network::Regtest)
.unwrap();
let ldk4_fund_addr = ldk4.bitcoind_client.get_new_address().await;
let ldk4_addr_string = ldk4_fund_addr.to_string();
let ldk4_addr = bitcoincore_rpc::bitcoin::Address::from_str(&ldk4_addr_string)
.unwrap()
.require_network(bitcoincore_rpc::bitcoin::Network::Regtest)
.unwrap();
bitcoind
.node
.client
.generate_to_address(6, &ldk3_addr)
.unwrap();
bitcoind
.node
.client
.generate_to_address(6, &ldk4_addr)
.unwrap();
lnd.wait_for_chain_sync().await;
ldk3.open_channel(ldk2_pubkey, addr_2, 200000, 10000000, true)
.await
.unwrap();
ldk4.open_channel(ldk2_pubkey, addr_2, 200000, 10000000, true)
.await
.unwrap();
lnd.wait_for_graph_sync().await;
bitcoind
.node
.client
.generate_to_address(6, &ldk3_addr)
.unwrap();
lnd.wait_for_chain_sync().await;
let lnd_addr = lnd
.address
.replace("localhost", "127.0.0.1")
.replace("https://", "");
ldk3.open_channel(
lnd_pubkey,
SocketAddr::from_str(&lnd_addr).unwrap(),
200000,
10000000,
true,
)
.await
.unwrap();
lnd.wait_for_graph_sync().await;
bitcoind
.node
.client
.generate_to_address(6, &ldk3_addr)
.unwrap();
lnd.wait_for_chain_sync().await;
ldk4.open_channel(
lnd_pubkey,
SocketAddr::from_str(&lnd_addr).unwrap(),
200000,
10000000,
true,
)
.await
.unwrap();
lnd.wait_for_graph_sync().await;
bitcoind
.node
.client
.generate_to_address(6, &ldk3_addr)
.unwrap();
lnd.wait_for_chain_sync().await;
ldk3.open_channel(ldk4_pubkey, addr_4, 200000, 10000000, true)
.await
.unwrap();
lnd.wait_for_graph_sync().await;
bitcoind
.node
.client
.generate_to_address(20, &ldk3_addr)
.unwrap();
lnd.wait_for_chain_sync().await;
lnd.wait_for_nodes_addresses(&[&ldk1, &ldk2, &ldk3, &ldk4])
.await;
let (shutdown, listener) = triggered::trigger();
let creds = validate_lnd_creds(
Some(PathBuf::from_str(&lnd.cert_path).unwrap()),
None,
Some(PathBuf::from_str(&lnd.macaroon_path).unwrap()),
None,
)
.unwrap();
let lnd_cfg = lndk::lnd::LndCfg::new(lnd.address.clone(), creds);
let signals = LifecycleSignals {
shutdown: shutdown.clone(),
listener,
};
let lndk_cfg = lndk::Cfg {
lnd: lnd_cfg,
signals,
skip_version_check: false,
rate_limit_count: 10,
rate_limit_period_secs: 1,
};
let handler = Arc::new(OfferHandler::new(
None,
None,
Some(lnd.client.clone().unwrap()),
));
let messenger = lndk::LndkOnionMessenger::new();
let create_offer_params = CreateOfferParams {
client: lnd.client.clone().unwrap(),
amount_msats: 20_000,
chain: Network::Regtest,
description: None,
issuer: None,
quantity: None,
expiry: None,
};
lnd.wait_for_addresses_to_sync(ldk1_pubkey).await;
let offer = handler.create_offer(create_offer_params).await;
assert!(offer.is_ok());
let offer = offer.unwrap();
// we check that according the current topology, there are 3 blinded paths available.
assert!(offer.paths().len() == 3);
select! {
val = messenger.run(lndk_cfg, Arc::clone(&handler)) => {
panic!("lndk should not have completed first {:?}", val);