Skip to content

Non-blocking Interface for Payjoin State Machine #1446

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
xstoicunicornx wants to merge 3 commits into
base: master
Choose a base branch
from
Open

Non-blocking Interface for Payjoin State Machine #1446

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
4e9d40b
Add non-blocking receive interface
xstoicunicornx May 13, 2026
3d6305d
Add FFI bindings for non-blocking receive interface
xstoicunicornx May 14, 2026
8aa8285
Update payjoin-cli to non-blocking receive interface
xstoicunicornx May 20, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
46 changes: 28 additions & 18 deletions payjoin-cli/src/app/v1.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,7 @@ use hyper_util::rt::TokioIo;
use payjoin::bitcoin::consensus::encode::serialize_hex;
use payjoin::bitcoin::{Amount, FeeRate};
use payjoin::receive::v1::{PayjoinProposal, UncheckedOriginalPayload};
use payjoin::receive::Error;
use payjoin::receive::{mark_checklist, Error};
use payjoin::send::v1::SenderBuilder;
use payjoin::{ImplementationError, IntoUrl, Uri};
use tokio::net::TcpListener;
Expand Down Expand Up @@ -348,35 +348,43 @@ impl App {
let wallet = self.wallet();

// Receive Check 1: Can Broadcast
let proposal = proposal.check_broadcast_suitability(None, |tx| {
wallet
.can_broadcast(tx)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
})?;
let is_broadcast_suitable = wallet
.can_broadcast(&proposal.extract_tx_to_check_broadcast_suitability())
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
.map_err(Error::Implementation)?;
let proposal = proposal.apply_broadcast_suitability(None, is_broadcast_suitable)?;
tracing::trace!("check1");

// in a payment processor where the sender could go offline, this is where you schedule to broadcast the original_tx
let _to_broadcast_in_failure_case = proposal.extract_tx_to_schedule_broadcast();

// Receive Check 2: receiver can't sign for proposal inputs
let proposal = proposal.check_inputs_not_owned(&mut |outpoint| {
let checklist = proposal.inputs_owned_checklist();
let marked_checklist = mark_checklist(checklist, &mut |outpoint| {
wallet
.is_my_outpoint(outpoint)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
})?;
})
.map_err(Error::Implementation)?;
let proposal = proposal.apply_inputs_owned_checklist(marked_checklist)?;
tracing::trace!("check2");

// Receive Check 3: have we seen this input before? More of a check for non-interactive i.e. payment processor receivers.
let payjoin = proposal.check_no_inputs_seen_before(&mut |input| {
Ok(self.db.insert_input_seen_before(*input)?)
})?;
let checklist = proposal.inputs_seen_checklist();
let marked_checklist =
mark_checklist(checklist, &mut |input| Ok(self.db.insert_input_seen_before(*input)?))
.map_err(Error::Implementation)?;
let payjoin = proposal.apply_inputs_seen_checklist(marked_checklist)?;
tracing::trace!("check3");

let payjoin = payjoin.identify_receiver_outputs(&mut |output_script| {
let checklist = payjoin.outputs_owned_checklist();
let marked_checklist = mark_checklist(checklist, &mut |output_script| {
wallet
.is_mine(output_script)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
})?;
})
.map_err(Error::Implementation)?;
let payjoin = payjoin.apply_outputs_owned_checklist(marked_checklist)?;

let payjoin = payjoin
.substitute_receiver_script(
Expand All @@ -396,11 +404,13 @@ impl App {
let provisional_payjoin =
wants_fee_range.apply_fee_range(None, self.config.max_fee_rate)?;

let payjoin_proposal = provisional_payjoin.finalize_proposal(|psbt| {
self.wallet
.process_psbt(psbt)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
})?;
let psbt = provisional_payjoin.psbt_to_sign();
let signed_psbt = self
.wallet
.process_psbt(&psbt)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
.map_err(Error::Implementation)?;
let payjoin_proposal = provisional_payjoin.finalize_signed_proposal(&signed_psbt)?;
Ok(payjoin_proposal)
}
}
Expand Down
63 changes: 30 additions & 33 deletions payjoin-cli/src/app/v2/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@ use anyhow::{anyhow, Context, Result};
use payjoin::bitcoin::consensus::encode::serialize_hex;
use payjoin::bitcoin::{Amount, FeeRate, Transaction};
use payjoin::persist::{OptionalTransitionOutcome, SessionPersister};
use payjoin::receive::mark_checklist;
use payjoin::receive::v2::{
replay_event_log as replay_receiver_event_log, HasReplyableError, Initialized,
MaybeInputsOwned, MaybeInputsSeen, Monitor, OutputsUnknown, PayjoinProposal,
Expand Down Expand Up @@ -1021,13 +1022,11 @@ impl App {
persister: &ReceiverPersister,
) -> Result<ReceiveSession> {
let wallet = self.wallet();
let proposal = proposal
.check_broadcast_suitability(None, |tx| {
wallet
.can_broadcast(tx)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
})
.save(persister)?;
let is_broadcast_suitable = wallet
.can_broadcast(&proposal.extract_tx_to_check_broadcast_suitability())
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))?;
let proposal =
proposal.apply_broadcast_suitability(None, is_broadcast_suitable).save(persister)?;

persister.print(
"Fallback transaction received. Consider broadcasting this to get paid if the Payjoin fails:",
Expand All @@ -1042,13 +1041,13 @@ impl App {
persister: &ReceiverPersister,
) -> Result<ReceiveSession> {
let wallet = self.wallet();
let proposal = proposal
.check_inputs_not_owned(&mut |outpoint| {
wallet
.is_my_outpoint(outpoint)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
})
.save(persister)?;
let checklist = proposal.inputs_owned_checklist();
let marked_checklist = mark_checklist(checklist, &mut |outpoint| {
wallet
.is_my_outpoint(outpoint)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
})?;
let proposal = proposal.apply_inputs_owned_checklist(marked_checklist).save(persister)?;
Ok(ReceiveSession::MaybeInputsSeen(proposal))
}

Expand All @@ -1057,11 +1056,11 @@ impl App {
proposal: Receiver<MaybeInputsSeen>,
persister: &ReceiverPersister,
) -> Result<ReceiveSession> {
let proposal = proposal
.check_no_inputs_seen_before(&mut |input| {
Ok(self.db.insert_input_seen_before(*input)?)
})
.save(persister)?;
let checklist = proposal.inputs_seen_checklist();
let marked_checklist = mark_checklist(checklist, &mut |input| {
Ok(self.db.insert_input_seen_before(*input)?)
})?;
let proposal = proposal.apply_inputs_seen_checklist(marked_checklist).save(persister)?;
Ok(ReceiveSession::OutputsUnknown(proposal))
}

Expand All @@ -1071,13 +1070,13 @@ impl App {
persister: &ReceiverPersister,
) -> Result<ReceiveSession> {
let wallet = self.wallet();
let proposal = proposal
.identify_receiver_outputs(&mut |output_script| {
wallet
.is_mine(output_script)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
})
.save(persister)?;
let checklist = proposal.outputs_owned_checklist();
let marked_checklist = mark_checklist(checklist, &mut |output_script| {
wallet
.is_mine(output_script)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
})?;
let proposal = proposal.apply_outputs_owned_checklist(marked_checklist).save(persister)?;
Ok(ReceiveSession::WantsOutputs(proposal))
}

Expand Down Expand Up @@ -1126,13 +1125,11 @@ impl App {
persister: &ReceiverPersister,
) -> Result<ReceiveSession> {
let wallet = self.wallet();
let proposal = proposal
.finalize_proposal(|psbt| {
wallet
.process_psbt(psbt)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))
})
.save(persister)?;
let psbt = proposal.psbt_to_sign();
let signed_psbt = wallet
.process_psbt(&psbt)
.map_err(|e| ImplementationError::from(e.into_boxed_dyn_error()))?;
let proposal = proposal.finalize_signed_proposal(&signed_psbt).save(persister)?;
Ok(ReceiveSession::PayjoinProposal(proposal))
}

Expand Down
Loading
Loading