[RBF] Transactions with changed outputs incorrectly trigger Dropped event

[moisesPompilio]

Describe the bug
When performing an RBF that changes the outputs using the WalletEvent API in BDK v2.2, the original transaction is marked as dropped instead of replaced. This seems incorrect since it is a valid RBF event.

To Reproduce

1. Create a transaction and broadcast it.
2. Broadcast an RBF version of it that changes the outputs (not only the fee).
3. Observe that BDK emits a Dropped event instead of Replaced.

Expected behavior
The transaction should be detected as Replaced, not Dropped, since it is an RBF replacement.

Build environment

• BDK 2.2
• OS+version: Arch Linux
• Rust/Cargo version: 1.90.0

Which backend(s) are relevant (if any)?

• Electrum
• Esplora
• Bitcoin Core RPC
• None / not backend-related (e.g. bdk_chain, bdk_core)
• Other (please specify): ____

Is this blocking production use?

• Yes
• No

Project or organization (optional)
Testing integration between BDK and LDK.

Additional context
Found while testing the new BDK event model in LDK. The issue appears when the replaced transaction modifies outputs, as BDK seems to determine replacement status based only on outputs instead of inputs. The behavior is consistent across RPC, Esplora, and Electrum backends, indicating the issue likely originates from BDK’s event classification logic rather than the backend.

cc @oleonardolima
cc @notmandatory

[notmandatory]

Thanks for the detailed issue, I'll look into in and let you know what I find. A few questions:

1. do you change all the outputs or leave some of the original outputs?
2. how do you change the outputs? just need addresses?
3. do you keep only the original inputs? Or adding new inputs?

[moisesPompilio]

1. do you change all the outputs or leave some of the original outputs?

Not all outputs, I only change the ones tracked by BDK since I’m testing only the on-chain payment detection of my Lightning node.

2. how do you change the outputs? just need addresses?

Yes, I get new addresses from Bitcoin Core.
example:

// `tx` is a Transaction struct from rust-bitcoin
tx.output.iter_mut().for_each(|output| {
    if scripts_buf.contains(&output.script_pubkey) { // scripts_buf is a Vec of my 'addresses' scripts
         // using electrsd library, `bitcoind` here is a `Client` from `corepc_node`
        let new_addr = bitcoind.new_address().unwrap(); // returns an Address struct from rust-bitcoin,
        output.script_pubkey = new_addr.script_pubkey();
    }
});

3. do you keep only the original inputs? Or adding new inputs?

I keep the original inputs, no new ones are added.

[notmandatory]

I wrote a little unit test that changes the RBF transactions output addresses and it passes as expected. I wonder if this could be an issue with the data the wallet gets from the blockchain client.

In my tests I'm assuming the wallet::Update being applied contains the original and new RBF tx. This should be the case when syncing after broadcasting the new RBF tx. Are you seeing the new RBF tx in the wallet::Update you get back from syncing with your blockchain clients?

fn random_p2pkh_address() -> Address {
    let secp = Secp256k1::new();
    let (_, public_key) = secp.generate_keypair(&mut rand::thread_rng());
    Address::p2pkh(&PublicKey::new(public_key), Testnet)
}

#[test]
fn test_tx_replaced_diff_outputs_event() {
    let (desc, change_desc) = get_test_wpkh_and_change_desc();
    let (mut wallet, _, update) = new_wallet_and_funding_update(desc, Some(change_desc));
    // ignore funding events
    let _events = wallet.apply_update_events(update).unwrap();

    // create original tx
    let mut builder = wallet.build_tx();
    builder.add_recipient(
        Address::from_str("tb1q6yn66vajcctph75pvylgkksgpp6nq04ppwct9a")
            .unwrap()
            .assume_checked(),
        Amount::from_sat(10_000),
    );
    let mut psbt = builder.finish().unwrap();
    wallet.sign(&mut psbt, SignOptions::default()).unwrap();
    let orig_tx = Arc::new(psbt.extract_tx().unwrap());
    let orig_txid = orig_tx.compute_txid();

    // update wallet with original tx
    let mut update = Update::default();
    update.tx_update.txs = vec![orig_tx.clone()];
    update.tx_update.seen_ats = [(orig_txid, 210)].into();
    let events = wallet.apply_update_events(update).unwrap();
    assert_eq!(events.len(), 1);
    assert!(
        matches!(&events[0], WalletEvent::TxUnconfirmed {tx, ..} if tx.compute_txid() == orig_txid)
    );

    // create rbf tx
    let mut builder = wallet.build_fee_bump(orig_txid).unwrap();
    builder.fee_rate(FeeRate::from_sat_per_vb(10).unwrap());
    let mut psbt = builder.finish().unwrap();
    wallet.sign(&mut psbt, SignOptions::default()).unwrap();
    let mut rbf_tx = psbt.extract_tx().unwrap();

    // change outputs to new addresses
    rbf_tx.output.iter_mut().for_each(|output| {
            output.script_pubkey = random_p2pkh_address().script_pubkey();
    });
    let rbf_txid = rbf_tx.compute_txid();

    // update wallet with rbf tx
    let mut update = Update::default();
    update.tx_update.txs = vec![Arc::new(rbf_tx.clone())];
    update.tx_update.evicted_ats = [(orig_txid, 220)].into();
    update.tx_update.seen_ats = [(rbf_txid, 220)].into();

    let events = wallet.apply_update_events(update).unwrap();
    assert_eq!(events.len(), 2);
    assert!(matches!(events[0], WalletEvent::TxUnconfirmed { txid, .. } if txid == rbf_txid));
    assert!(
        matches!(&events[1], WalletEvent::TxReplaced {txid, conflicts, ..} if *txid == orig_txid && conflicts.len() == 1 &&
            conflicts.contains(&(0, rbf_txid)))
    );
}