Skip to content

Commit 773d497

Browse files
jbesraajbesraa
committed
test payjoin integartion
1 parent accf6a8 commit 773d497

File tree

2 files changed

+98
-190
lines changed

2 files changed

+98
-190
lines changed

Diff for: ‎tests/integration_tests_payjoin.rs

+19-190
Original file line numberDiff line numberDiff line change
@@ -1,211 +1,40 @@
11
mod common;
2-
use std::{thread::sleep, time::Duration};
32

43
use crate::common::{
5-
expect_channel_pending_event, expect_channel_ready_event, generate_blocks_and_wait,
6-
premine_and_distribute_funds, setup_two_nodes, wait_for_tx,
4+
generate_blocks_and_wait, premine_and_distribute_funds, setup_two_payjoin_nodes, wait_for_tx,
75
};
86
use bitcoin::Amount;
9-
use bitcoincore_rpc::{Client as BitcoindClient, RpcApi};
107
use common::setup_bitcoind_and_electrsd;
11-
use ldk_node::Event;
12-
13-
#[test]
14-
fn send_receive_with_channel_opening_payjoin_transaction() {
15-
let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
16-
let (node_a, node_b) = setup_two_nodes(&electrsd, false, true);
17-
let addr_b = node_b.onchain_payment().new_address().unwrap();
18-
let premine_amount_sat = 100_000_00;
19-
premine_and_distribute_funds(
20-
&bitcoind.client,
21-
&electrsd.client,
22-
vec![addr_b],
23-
Amount::from_sat(premine_amount_sat),
24-
);
25-
node_a.sync_wallets().unwrap();
26-
node_b.sync_wallets().unwrap();
27-
assert_eq!(node_a.list_balances().spendable_onchain_balance_sats, 0);
28-
assert_eq!(node_b.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
29-
assert_eq!(node_a.next_event(), None);
30-
assert_eq!(node_a.list_channels().len(), 0);
31-
assert_eq!(node_b.next_event(), None);
32-
assert_eq!(node_b.list_channels().len(), 0);
33-
let funding_amount_sat = 80_000;
34-
let node_b_listening_address = node_b.listening_addresses().unwrap().get(0).unwrap().clone();
35-
let payjoin_uri = node_a
36-
.request_payjoin_transaction_with_channel_opening(
37-
funding_amount_sat,
38-
None,
39-
false,
40-
node_b.node_id(),
41-
node_b_listening_address,
42-
)
43-
.unwrap();
44-
assert!(node_b
45-
.send_payjoin_transaction(
46-
payjoin::Uri::try_from(payjoin_uri.to_string()).unwrap().assume_checked()
47-
)
48-
.is_ok());
49-
expect_channel_pending_event!(node_a, node_b.node_id());
50-
expect_channel_pending_event!(node_b, node_a.node_id());
51-
let channels = node_a.list_channels();
52-
let channel = channels.get(0).unwrap();
53-
wait_for_tx(&electrsd.client, channel.funding_txo.unwrap().txid);
54-
sleep(Duration::from_secs(1));
55-
generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
56-
node_a.sync_wallets().unwrap();
57-
node_b.sync_wallets().unwrap();
58-
expect_channel_ready_event!(node_a, node_b.node_id());
59-
expect_channel_ready_event!(node_b, node_a.node_id());
60-
let channels = node_a.list_channels();
61-
let channel = channels.get(0).unwrap();
62-
assert_eq!(channel.channel_value_sats, funding_amount_sat);
63-
assert_eq!(channel.confirmations.unwrap(), 6);
64-
assert!(channel.is_channel_ready);
65-
assert!(channel.is_usable);
66-
67-
assert_eq!(node_a.list_peers().get(0).unwrap().is_connected, true);
68-
assert_eq!(node_a.list_peers().get(0).unwrap().is_persisted, true);
69-
assert_eq!(node_a.list_peers().get(0).unwrap().node_id, node_b.node_id());
70-
71-
let invoice_amount_1_msat = 2500_000;
72-
let invoice = node_b.bolt11_payment().receive(invoice_amount_1_msat, "test", 1000).unwrap();
73-
assert!(node_a.bolt11_payment().send(&invoice).is_ok());
74-
}
758

769
#[test]
7710
fn send_receive_regular_payjoin_transaction() {
7811
let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
79-
let (node_a, node_b) = setup_two_nodes(&electrsd, false, true);
80-
let addr_b = node_b.onchain_payment().new_address().unwrap();
12+
let (node_a_pj_receiver, node_b_pj_sender) = setup_two_payjoin_nodes(&electrsd, false);
13+
let addr_b = node_b_pj_sender.onchain_payment().new_address().unwrap();
8114
let premine_amount_sat = 100_000_00;
8215
premine_and_distribute_funds(
8316
&bitcoind.client,
8417
&electrsd.client,
8518
vec![addr_b],
8619
Amount::from_sat(premine_amount_sat),
8720
);
88-
node_a.sync_wallets().unwrap();
89-
node_b.sync_wallets().unwrap();
90-
assert_eq!(node_b.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
91-
assert_eq!(node_a.list_balances().spendable_onchain_balance_sats, 0);
92-
assert_eq!(node_a.next_event(), None);
93-
assert_eq!(node_a.list_channels().len(), 0);
94-
let payjoin_uri = node_a.request_payjoin_transaction(80_000).unwrap();
95-
assert!(node_b
96-
.send_payjoin_transaction(
97-
payjoin::Uri::try_from(payjoin_uri.to_string()).unwrap().assume_checked()
98-
)
99-
.is_ok());
100-
sleep(Duration::from_secs(3));
101-
generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
102-
node_a.sync_wallets().unwrap();
103-
node_b.sync_wallets().unwrap();
104-
let node_a_balance = node_a.list_balances();
105-
let node_b_balance = node_b.list_balances();
106-
assert_eq!(node_a_balance.total_onchain_balance_sats, 80000);
107-
assert!(node_b_balance.total_onchain_balance_sats < premine_amount_sat - 80000);
108-
}
109-
110-
mod payjoin_v1 {
111-
use bitcoin::address::NetworkChecked;
112-
use bitcoin::base64;
113-
use bitcoin::Txid;
114-
use bitcoincore_rpc::Client as BitcoindClient;
115-
use bitcoincore_rpc::RpcApi;
116-
use std::collections::HashMap;
117-
use std::str::FromStr;
118-
119-
use bitcoincore_rpc::bitcoin::psbt::Psbt;
120-
121-
pub fn send(
122-
sender_wallet: &BitcoindClient, payjoin_uri: payjoin::Uri<'static, NetworkChecked>,
123-
) -> Txid {
124-
let amount_to_send = payjoin_uri.amount.unwrap();
125-
let receiver_address = payjoin_uri.address.clone();
126-
let mut outputs = HashMap::with_capacity(1);
127-
outputs.insert(receiver_address.to_string(), amount_to_send);
128-
let options = bitcoincore_rpc::json::WalletCreateFundedPsbtOptions {
129-
lock_unspent: Some(false),
130-
fee_rate: Some(bitcoincore_rpc::bitcoin::Amount::from_sat(10000)),
131-
..Default::default()
132-
};
133-
let sender_psbt = sender_wallet
134-
.wallet_create_funded_psbt(
135-
&[], // inputs
136-
&outputs,
137-
None, // locktime
138-
Some(options),
139-
None,
140-
)
141-
.unwrap();
142-
let psbt =
143-
sender_wallet.wallet_process_psbt(&sender_psbt.psbt, None, None, None).unwrap().psbt;
144-
let psbt = Psbt::from_str(&psbt).unwrap();
145-
let (req, ctx) =
146-
payjoin::send::RequestBuilder::from_psbt_and_uri(psbt.clone(), payjoin_uri)
147-
.unwrap()
148-
.build_with_additional_fee(
149-
bitcoincore_rpc::bitcoin::Amount::from_sat(1),
150-
None,
151-
bitcoincore_rpc::bitcoin::FeeRate::MIN,
152-
true,
153-
)
154-
.unwrap()
155-
.extract_v1()
156-
.unwrap();
157-
let url_http = req.url.as_str().replace("https", "http");
158-
let res = reqwest::blocking::Client::new();
159-
let res = res
160-
.post(&url_http)
161-
.body(req.body.clone())
162-
.header("content-type", "text/plain")
163-
.send()
164-
.unwrap();
165-
let res = res.text().unwrap();
166-
let psbt = ctx.process_response(&mut res.as_bytes()).unwrap();
167-
let psbt = sender_wallet
168-
.wallet_process_psbt(&base64::encode(psbt.serialize()), None, None, None)
169-
.unwrap()
170-
.psbt;
171-
let tx = sender_wallet.finalize_psbt(&psbt, Some(true)).unwrap().hex.unwrap();
172-
let txid = sender_wallet.send_raw_transaction(&tx).unwrap();
173-
txid
174-
}
175-
}
176-
177-
#[test]
178-
fn receive_payjoin_version_1() {
179-
let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
180-
let payjoin_sender_wallet: BitcoindClient = bitcoind.create_wallet("payjoin_sender").unwrap();
181-
let (node_a, _) = setup_two_nodes(&electrsd, false, true);
182-
let addr_sender = payjoin_sender_wallet.get_new_address(None, None).unwrap().assume_checked();
183-
let premine_amount_sat = 100_000_00;
184-
premine_and_distribute_funds(
185-
&bitcoind.client,
186-
&electrsd.client,
187-
vec![addr_sender],
188-
Amount::from_sat(premine_amount_sat),
189-
);
190-
node_a.sync_wallets().unwrap();
191-
assert_eq!(node_a.list_balances().spendable_onchain_balance_sats, 0);
192-
assert_eq!(
193-
payjoin_sender_wallet.get_balances().unwrap().mine.trusted.to_sat(),
194-
premine_amount_sat
195-
);
196-
assert_eq!(node_a.next_event(), None);
197-
assert_eq!(node_a.list_channels().len(), 0);
198-
let pj_uri = node_a.request_payjoin_transaction(80_000).unwrap();
199-
payjoin_v1::send(
200-
&payjoin_sender_wallet,
201-
payjoin::Uri::try_from(pj_uri.to_string()).unwrap().assume_checked(),
21+
node_a_pj_receiver.sync_wallets().unwrap();
22+
node_b_pj_sender.sync_wallets().unwrap();
23+
assert_eq!(node_b_pj_sender.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
24+
assert_eq!(node_a_pj_receiver.list_balances().spendable_onchain_balance_sats, 0);
25+
assert_eq!(node_a_pj_receiver.next_event(), None);
26+
assert_eq!(node_a_pj_receiver.list_channels().len(), 0);
27+
let payjoin_uri = node_a_pj_receiver.request_payjoin_transaction(80_000).unwrap();
28+
let txid = node_b_pj_sender.send_payjoin_transaction(
29+
payjoin::Uri::try_from(payjoin_uri.to_string()).unwrap().assume_checked(),
20230
);
203-
sleep(Duration::from_secs(3));
31+
dbg!(&txid);
32+
wait_for_tx(&electrsd.client, txid.unwrap().unwrap());
20433
generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
205-
node_a.sync_wallets().unwrap();
206-
let node_a_balance = node_a.list_balances();
34+
node_a_pj_receiver.sync_wallets().unwrap();
35+
node_b_pj_sender.sync_wallets().unwrap();
36+
let node_a_balance = node_a_pj_receiver.list_balances();
37+
let node_b_balance = node_b_pj_sender.list_balances();
20738
assert_eq!(node_a_balance.total_onchain_balance_sats, 80000);
39+
assert!(node_b_balance.total_onchain_balance_sats < premine_amount_sat - 80000);
20840
}
209-
210-
// test validation of payjoin transaction fails
211-
// test counterparty doesnt return fundingsigned

Diff for: ‎tests/integration_tests_payjoin_lightning.rs

+79
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,79 @@
1+
mod common;
2+
use std::{thread::sleep, time::Duration};
3+
4+
use crate::common::{
5+
expect_channel_pending_event, expect_channel_ready_event, generate_blocks_and_wait,
6+
premine_and_distribute_funds, setup_two_payjoin_nodes, wait_for_tx,
7+
};
8+
use bitcoin::Amount;
9+
use common::setup_bitcoind_and_electrsd;
10+
use ldk_node::Event;
11+
12+
#[test]
13+
fn send_receive_with_channel_opening_payjoin_transaction() {
14+
let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
15+
let (node_a, node_b) = setup_two_payjoin_nodes(&electrsd, false);
16+
let addr_b = node_b.onchain_payment().new_address().unwrap();
17+
let premine_amount_sat = 100_000_00;
18+
premine_and_distribute_funds(
19+
&bitcoind.client,
20+
&electrsd.client,
21+
vec![addr_b],
22+
Amount::from_sat(premine_amount_sat),
23+
);
24+
node_a.sync_wallets().unwrap();
25+
node_b.sync_wallets().unwrap();
26+
assert_eq!(node_a.list_balances().spendable_onchain_balance_sats, 0);
27+
assert_eq!(node_b.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
28+
assert_eq!(node_a.next_event(), None);
29+
assert_eq!(node_a.list_channels().len(), 0);
30+
assert_eq!(node_b.next_event(), None);
31+
assert_eq!(node_b.list_channels().len(), 0);
32+
let funding_amount_sat = 80_000;
33+
let node_b_listening_address = node_b.listening_addresses().unwrap().get(0).unwrap().clone();
34+
let payjoin_uri = node_a.request_payjoin_transaction_with_channel_opening(
35+
funding_amount_sat,
36+
None,
37+
false,
38+
node_b.node_id(),
39+
node_b_listening_address,
40+
);
41+
let payjoin_uri = match payjoin_uri {
42+
Ok(payjoin_uri) => payjoin_uri,
43+
Err(e) => {
44+
dbg!(&e);
45+
assert!(false);
46+
panic!("should generate payjoin uri");
47+
},
48+
};
49+
assert!(node_b
50+
.send_payjoin_transaction(
51+
payjoin::Uri::try_from(payjoin_uri.to_string()).unwrap().assume_checked()
52+
)
53+
.is_ok());
54+
expect_channel_pending_event!(node_a, node_b.node_id());
55+
expect_channel_pending_event!(node_b, node_a.node_id());
56+
let channels = node_a.list_channels();
57+
let channel = channels.get(0).unwrap();
58+
wait_for_tx(&electrsd.client, channel.funding_txo.unwrap().txid);
59+
sleep(Duration::from_secs(1));
60+
generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
61+
node_a.sync_wallets().unwrap();
62+
node_b.sync_wallets().unwrap();
63+
expect_channel_ready_event!(node_a, node_b.node_id());
64+
expect_channel_ready_event!(node_b, node_a.node_id());
65+
let channels = node_a.list_channels();
66+
let channel = channels.get(0).unwrap();
67+
assert_eq!(channel.channel_value_sats, funding_amount_sat);
68+
assert_eq!(channel.confirmations.unwrap(), 6);
69+
assert!(channel.is_channel_ready);
70+
assert!(channel.is_usable);
71+
72+
assert_eq!(node_a.list_peers().get(0).unwrap().is_connected, true);
73+
assert_eq!(node_a.list_peers().get(0).unwrap().is_persisted, true);
74+
assert_eq!(node_a.list_peers().get(0).unwrap().node_id, node_b.node_id());
75+
76+
let invoice_amount_1_msat = 2500_000;
77+
let invoice = node_b.bolt11_payment().receive(invoice_amount_1_msat, "test", 1000).unwrap();
78+
assert!(node_a.bolt11_payment().send(&invoice).is_ok());
79+
}

0 commit comments

Comments
 (0)