tests

Author: jbesraa

Cargo.toml

@@ -86,6 +86,9 @@ bitcoincore-rpc = { version = "0.17.0", default-features = false }
 proptest = "1.0.0"
 regex = "1.5.6"
 
+payjoin = { version = "0.16.0", default-features = false, features = ["send", "v2", "receive"] }
+reqwest = { version = "0.11", default-features = false, features = ["json", "rustls-tls", "blocking"] }
+
 [target.'cfg(not(no_download))'.dev-dependencies]
 electrsd = { version = "0.26.0", features = ["legacy", "esplora_a33e97e1", "bitcoind_25_0"] }
 

tests/common/mod.rs

@@ -147,6 +147,57 @@ macro_rules! expect_payment_successful_event {
 
 pub(crate) use expect_payment_successful_event;
 
+macro_rules! expect_payjoin_tx_pending_event {
+	($node: expr) => {{
+		match $node.wait_next_event() {
+			ref e @ Event::PayjoinPaymentPending { txid, .. } => {
+				println!("{} got event {:?}", $node.node_id(), e);
+				$node.event_handled();
+				txid
+			},
+			ref e => {
+				panic!("{} got unexpected event!: {:?}", std::stringify!($node), e);
+			},
+		}
+	}};
+}
+
+pub(crate) use expect_payjoin_tx_pending_event;
+
+macro_rules! expect_payjoin_tx_sent_successfully_event {
+	($node: expr) => {{
+		match $node.wait_next_event() {
+			ref e @ Event::PayjoinPaymentSuccessful { txid, .. } => {
+				println!("{} got event {:?}", $node.node_id(), e);
+				$node.event_handled();
+				txid
+			},
+			ref e => {
+				panic!("{} got unexpected event!: {:?}", std::stringify!($node), e);
+			},
+		}
+	}};
+}
+
+pub(crate) use expect_payjoin_tx_sent_successfully_event;
+
+macro_rules! expect_payjoin_tx_broadcasted {
+	($node: expr) => {{
+		match $node.wait_next_event() {
+			ref e @ Event::PayjoinPaymentBroadcasted { txid, .. } => {
+				println!("{} got event {:?}", $node.node_id(), e);
+				$node.event_handled();
+				txid
+			},
+			ref e => {
+				panic!("{} got unexpected event!: {:?}", std::stringify!($node), e);
+			},
+		}
+	}};
+}
+
+pub(crate) use expect_payjoin_tx_broadcasted;
+
 pub(crate) fn setup_bitcoind_and_electrsd() -> (BitcoinD, ElectrsD) {
 	let bitcoind_exe =
 		env::var("BITCOIND_EXE").ok().or_else(|| bitcoind::downloaded_exe_path().ok()).expect(
@@ -270,6 +321,20 @@ pub(crate) fn setup_node(electrsd: &ElectrsD, config: Config) -> TestNode {
 	node
 }
 
+pub(crate) fn setup_payjoin_node(electrsd: &ElectrsD, config: Config) -> TestNode {
+	let esplora_url = format!("http://{}", electrsd.esplora_url.as_ref().unwrap());
+	setup_builder!(builder, config);
+	builder.set_esplora_server(esplora_url.clone());
+	let payjoin_relay = "https://pj.bobspacebkk.com".to_string();
+	builder.set_payjoin_config(payjoin_relay).unwrap();
+	let test_sync_store = Arc::new(TestSyncStore::new(config.storage_dir_path.into()));
+	let node = builder.build_with_store(test_sync_store).unwrap();
+	node.start().unwrap();
+	assert!(node.status().is_running);
+	assert!(node.status().latest_fee_rate_cache_update_timestamp.is_some());
+	node
+}
+
 pub(crate) fn generate_blocks_and_wait<E: ElectrumApi>(
 	bitcoind: &BitcoindClient, electrs: &E, num: usize,
 ) {

tests/integration_tests_payjoin.rs

@@ -0,0 +1,169 @@
+mod common;
+
+use common::{
+	expect_payjoin_tx_sent_successfully_event, generate_blocks_and_wait,
+	premine_and_distribute_funds, setup_bitcoind_and_electrsd, wait_for_tx,
+};
+
+use bitcoin::Amount;
+use ldk_node::{
+	payment::{PaymentDirection, PaymentKind, PaymentStatus},
+	Event,
+};
+use payjoin::{
+	receive::v2::{Enrolled, Enroller},
+	OhttpKeys, PjUriBuilder,
+};
+
+use crate::common::{
+	expect_payjoin_tx_broadcasted, expect_payjoin_tx_pending_event, random_config, setup_payjoin_node, setup_two_nodes
+};
+
+struct PayjoinReceiver {
+	ohttp_keys: OhttpKeys,
+	enrolled: Enrolled,
+}
+
+impl PayjoinReceiver {
+	fn enroll() -> Self {
+		let payjoin_directory = payjoin::Url::parse("https://payjo.in").unwrap();
+		let payjoin_relay = payjoin::Url::parse("https://pj.bobspacebkk.com").unwrap();
+		let ohttp_keys = {
+			let payjoin_directory = payjoin_directory.join("/ohttp-keys").unwrap();
+			let proxy = reqwest::Proxy::all(payjoin_relay.clone()).unwrap();
+			let client = reqwest::blocking::Client::builder().proxy(proxy).build().unwrap();
+			let response = client.get(payjoin_directory).send().unwrap();
+			let response = response.bytes().unwrap();
+			OhttpKeys::decode(response.to_vec().as_slice()).unwrap()
+		};
+		dbg!(&ohttp_keys);
+		let mut enroller = Enroller::from_directory_config(
+			payjoin_directory.clone(),
+			ohttp_keys.clone(),
+			payjoin_relay.clone(),
+		);
+		let (req, ctx) = enroller.extract_req().unwrap();
+		let mut headers = reqwest::header::HeaderMap::new();
+		headers.insert(
+			reqwest::header::CONTENT_TYPE,
+			reqwest::header::HeaderValue::from_static("message/ohttp-req"),
+		);
+		let response = reqwest::blocking::Client::new()
+			.post(&req.url.to_string())
+			.body(req.body)
+			.headers(headers)
+			.send()
+			.unwrap();
+		let response = match response.bytes() {
+			Ok(response) => response,
+			Err(_) => {
+				panic!("Error reading response");
+			},
+		};
+		let enrolled = enroller.process_res(response.to_vec().as_slice(), ctx).unwrap();
+		Self { ohttp_keys, enrolled }
+	}
+
+	pub(crate) fn receive(
+		&self, amount: bitcoin::Amount, receiving_address: bitcoin::Address,
+	) -> String {
+		let enrolled = self.enrolled.clone();
+		let fallback_target = enrolled.fallback_target();
+		let ohttp_keys = self.ohttp_keys.clone();
+		let pj_part = payjoin::Url::parse(&fallback_target).unwrap();
+		let payjoin_uri = PjUriBuilder::new(receiving_address, pj_part, Some(ohttp_keys.clone()))
+			.amount(amount)
+			.build();
+		payjoin_uri.to_string()
+	}
+
+	pub(crate) fn process_payjoin_request(self) {
+		let mut enrolled = self.enrolled;
+		let (req, context) = enrolled.extract_req().unwrap();
+
+		let client = reqwest::blocking::Client::new();
+		let response = client
+			.post(req.url.to_string())
+			.body(req.body)
+			.headers(PayjoinReceiver::ohttp_headers())
+			.send()
+			.unwrap();
+		let response = response.bytes().unwrap();
+		let response = enrolled.process_res(response.to_vec().as_slice(), context).unwrap();
+		let unchecked_proposal = response.unwrap();
+
+		let proposal = unchecked_proposal.assume_interactive_receiver();
+		let proposal = proposal.check_inputs_not_owned(|_script| Ok(false)).unwrap();
+		let proposal = proposal.check_no_mixed_input_scripts().unwrap();
+		let proposal = proposal.check_no_inputs_seen_before(|_outpoint| Ok(false)).unwrap();
+		let provisional_proposal = proposal.identify_receiver_outputs(|_script| Ok(true)).unwrap();
+
+		// Finalise Payjoin Proposal
+		let mut payjoin_proposal =
+			provisional_proposal.finalize_proposal(|psbt| Ok(psbt.clone()), None).unwrap();
+
+		let (receiver_request, _) = payjoin_proposal.extract_v2_req().unwrap();
+		reqwest::blocking::Client::new()
+			.post(&receiver_request.url.to_string())
+			.body(receiver_request.body)
+			.headers(PayjoinReceiver::ohttp_headers())
+			.send()
+			.unwrap();
+	}
+
+	fn ohttp_headers() -> reqwest::header::HeaderMap {
+		let mut headers = reqwest::header::HeaderMap::new();
+		headers.insert(
+			reqwest::header::CONTENT_TYPE,
+			reqwest::header::HeaderValue::from_static("message/ohttp-req"),
+		);
+		headers
+	}
+}
+
+#[test]
+fn send_receive_regular_payjoin_transaction() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let config_a = random_config(false);
+	let (receiver, _) = setup_two_nodes(&electrsd, false, false, false);
+	let payjoin_sender = setup_payjoin_node(&electrsd, config_a);
+	let addr_a = payjoin_sender.onchain_payment().new_address().unwrap();
+	let premine_amount_sat = 100_000_00;
+	premine_and_distribute_funds(
+		&bitcoind.client,
+		&electrsd.client,
+		vec![addr_a],
+		Amount::from_sat(premine_amount_sat),
+	);
+	payjoin_sender.sync_wallets().unwrap();
+	assert_eq!(payjoin_sender.list_balances().spendable_onchain_balance_sats, premine_amount_sat);
+	assert_eq!(payjoin_sender.list_balances().spendable_onchain_balance_sats, 100_000_00);
+	assert_eq!(payjoin_sender.next_event(), None);
+
+	let payjoin_receiver = PayjoinReceiver::enroll();
+	let payjoin_uri = payjoin_receiver
+		.receive(Amount::from_sat(80_000), receiver.onchain_payment().new_address().unwrap());
+	dbg!(&payjoin_uri);
+
+	assert!(payjoin_sender.payjoin_payment().send(payjoin_uri).is_ok());
+
+	let txid = expect_payjoin_tx_pending_event!(payjoin_sender);
+	let payments = payjoin_sender.list_payments();
+	let payment = payments.first().unwrap();
+	assert_eq!(payment.amount_msat, Some(80_000));
+	assert_eq!(payment.status, PaymentStatus::Pending);
+	assert_eq!(payment.direction, PaymentDirection::Outbound);
+	assert_eq!(payment.kind, PaymentKind::Payjoin);
+
+	payjoin_receiver.process_payjoin_request();
+
+	expect_payjoin_tx_broadcasted!(payjoin_sender);
+
+	wait_for_tx(&electrsd.client, txid);
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 3);
+	payjoin_sender.sync_wallets().unwrap();
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 4);
+	payjoin_sender.sync_wallets().unwrap();
+
+	expect_payjoin_tx_sent_successfully_event!(payjoin_sender);
+}