Skip to content

reject malformed unordered PSBTs - #111

Draft
yuval-block wants to merge 1 commit into
concurrent-psbt-fieldsfrom
enforce-concurrent-psbt-fields
Draft

yuval-block wants to merge 1 commit into
concurrent-psbt-fieldsfrom
enforce-concurrent-psbt-fields

Conversation

@yuval-block

Copy link
Copy Markdown
Collaborator

Check the values of the unordered PSBT fields: PSBT_GLOBAL_TX_UNORDERED must be 0x03, PSBT_GLOBAL_SORT_DETERMINISTIC 0x00 or 0x01, the sort seed at least 16 bytes long, and sort keys at most 32 bytes long.

Also reject PSBTs that break the modifiability invariants: a PSBT whose inputs or outputs are modifiable must be unordered, since its order would otherwise be lost, and an unordered PSBT must not have the SIGHASH_SINGLE bit set.

@yuval-block
yuval-block added this pull request to stack #113 November 14, 2026 02:24
@yuval-block yuval-block added this to the Semi-honest MVP milestone Nov 14, 2026
@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from a0900ae to 568bc71 Compare November 14, 2026 04:12
@github-actions

Copy link
Copy Markdown
range-diff for force push a0900aeb14 → 568bc715d0 November 14, 2026 04:12 UTC: 1 modified; 1 commit; base fc9b919e82 → 86a484d169 (diverged, 2 ahead and 2 behind)

reproduce: git range-diff fc9b919..a0900ae 86a484d..568bc71

1:  a0900aeb14 +358 -24 1f ! 1:  568bc715d0 +482 -22 1f reject malformed unordered PSBTs
1: a0900aeb14 ! 1: 568bc715d0 reject malformed unordered PSBTs
@@ crates/concurrent-psbt/src/psbt/tx.rs: use psbt_v2::v2::{Global, Psbt};
 -use super::input::{DuplicateInput, InputSet, ResultInputSet};
 -use super::output::{OutputSet, OutputSetError, ResultOutputSet, UniqueId};
 +use super::global::{
-+    GlobalExt, GlobalSortExt, PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE,
++    GlobalExt, GlobalSortExt, PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE,
 +    PSBT_GLOBAL_TX_UNORDERED_SUBTYPE, ResultGlobal, SortSeed,
 +};
 +use super::input::{DuplicateInput, InputSet, InputSortKeyExt, ResultInputSet, SortKey, out_point};
@@ crates/concurrent-psbt/src/psbt/tx.rs: pub enum UnorderedPsbtError {
      Conflict(Box<ResultUnorderedPsbt>),
 +    /// `PSBT_GLOBAL_TX_UNORDERED` is present but its value is not `0x03`.
 +    InvalidUnorderedFlag(Vec<u8>),
-+    /// `PSBT_GLOBAL_SORT_DETERMINISTIC` is present but its value is neither
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` is present but its value is neither
 +    /// `0x00` nor `0x01`.
-+    InvalidSortDeterministic(Vec<u8>),
-+    /// Inputs or outputs are modifiable but the PSBT is ordered. Reading it as
-+    /// unordered would discard its order.
-+    OrderedModifiable,
++    InvalidSortKeyDerivation(Vec<u8>),
++    /// `PSBT_GLOBAL_TX_UNORDERED` is absent, so the PSBT is ordered. Reading
++    /// it as unordered would discard its order.
++    NotUnordered,
 +    /// The PSBT is unordered but `tx_modifiable_flags` has the
 +    /// `Has SIGHASH_SINGLE` bit set.
 +    UnorderedSighashSingle,
@@ crates/concurrent-psbt/src/psbt/tx.rs: pub enum UnorderedPsbtError {
 +    /// The output at this position has a `PSBT_OUT_SORT_KEY` longer than
 +    /// [`SortKey::MAX_LEN`].
 +    OutputSortKeyTooLong(usize),
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` is `0x00`, so sort keys are never
++    /// derived, but `PSBT_GLOBAL_SORT_SEED` is set.
++    UnexpectedSortSeed,
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` is `0x01`, so every sort key is
++    /// derived, but the input spending this outpoint has a `PSBT_IN_SORT_KEY`.
++    UnexpectedInputSortKey(OutPoint),
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` is `0x01`, so every sort key is
++    /// derived, but the output at this position has a `PSBT_OUT_SORT_KEY`.
++    UnexpectedOutputSortKey(usize),
++    /// Two inputs, or two outputs, have this explicit sort key.
++    DuplicateSortKey(Vec<u8>),
  }
  
  impl From<DuplicateInput> for UnorderedPsbtError {
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl fmt::Display for UnorderedPsbtError
 +            Self::InvalidUnorderedFlag(value) => {
 +                write!(f, "PSBT_GLOBAL_TX_UNORDERED is {value:02x?}, not 0x03")
 +            }
-+            Self::InvalidSortDeterministic(value) => write!(
++            Self::InvalidSortKeyDerivation(value) => write!(
 +                f,
-+                "PSBT_GLOBAL_SORT_DETERMINISTIC is {value:02x?}, not 0x00 or 0x01"
++                "PSBT_GLOBAL_SORT_KEY_DERIVATION is {value:02x?}, not 0x00 or 0x01"
 +            ),
-+            Self::OrderedModifiable => {
-+                write!(f, "PSBT is modifiable but not marked unordered")
-+            }
++            Self::NotUnordered => write!(f, "PSBT is not marked unordered"),
 +            Self::UnorderedSighashSingle => {
 +                write!(f, "unordered PSBT has the SIGHASH_SINGLE flag set")
 +            }
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl fmt::Display for UnorderedPsbtError
 +                "sort key of output {index} is longer than {} bytes",
 +                SortKey::MAX_LEN
 +            ),
++            Self::UnexpectedSortSeed => write!(
++                f,
++                "PSBT_GLOBAL_SORT_SEED is set but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x00"
++            ),
++            Self::UnexpectedInputSortKey(outpoint) => write!(
++                f,
++                "the input spending {outpoint} has a sort key but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x01"
++            ),
++            Self::UnexpectedOutputSortKey(index) => write!(
++                f,
++                "output {index} has a sort key but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x01"
++            ),
++            Self::DuplicateSortKey(key) => write!(f, "duplicate sort key {key:02x?}"),
          }
      }
  }
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 -    /// outpoint or unique ID, or an output missing `PSBT_OUT_UNIQUE_ID` or
 -    /// with a long one), or
 +    /// Returns the errors of [`ResultUnorderedPsbt::try_from_psbt`] (malformed
-+    /// unordered flags, an ordered modifiable PSBT, a repeated outpoint or
++    /// unordered flags, an ordered PSBT, a repeated outpoint or
 +    /// unique ID, or an output missing `PSBT_OUT_UNIQUE_ID` or with a long
 +    /// one), or
      /// [`UnorderedPsbtError::Conflict`] if the declared counts disagree with
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 +    global.proprietaries.get(&key).map(Vec::as_slice)
 +}
 +
-+/// Check that a PSBT can be read as unordered: its unordered and
-+/// deterministic flags are well formed, it is unordered if anything is
-+/// modifiable, an unordered PSBT does not use `SIGHASH_SINGLE`, and its sort
-+/// seed and sort keys have valid sizes.
++/// Check that a PSBT can be read as unordered: it is marked unordered, its
++/// flags are well formed, it does not use `SIGHASH_SINGLE`, its sort seed and
++/// sort keys have valid sizes, the sort fields present agree with
++/// `PSBT_GLOBAL_SORT_KEY_DERIVATION`, and no two inputs or two outputs share an
++/// explicit sort key.
 +fn validate_unordered(psbt: &Psbt) -> Result<(), UnorderedPsbtError> {
 +    let global = &psbt.global;
-+    if let Some(value) = proprietary_value(global, PSBT_GLOBAL_TX_UNORDERED_SUBTYPE)
-+        && value != [0x03]
-+    {
-+        return Err(UnorderedPsbtError::InvalidUnorderedFlag(value.to_vec()));
++    match proprietary_value(global, PSBT_GLOBAL_TX_UNORDERED_SUBTYPE) {
++        None => return Err(UnorderedPsbtError::NotUnordered),
++        Some(value) if value != [0x03] => {
++            return Err(UnorderedPsbtError::InvalidUnorderedFlag(value.to_vec()));
++        }
++        Some(_) => {}
 +    }
-+    if let Some(value) = proprietary_value(global, PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE)
++    if let Some(value) = proprietary_value(global, PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE)
 +        && value != [0x00]
 +        && value != [0x01]
 +    {
-+        return Err(UnorderedPsbtError::InvalidSortDeterministic(value.to_vec()));
++        return Err(UnorderedPsbtError::InvalidSortKeyDerivation(value.to_vec()));
 +    }
-+    let flags = global.tx_modifiable_flags;
-+    if global.is_unordered() {
-+        if flags & HAS_SIGHASH_SINGLE != 0 {
-+            return Err(UnorderedPsbtError::UnorderedSighashSingle);
-+        }
-+    } else if flags & (INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE) != 0 {
-+        return Err(UnorderedPsbtError::OrderedModifiable);
++    if global.tx_modifiable_flags & HAS_SIGHASH_SINGLE != 0 {
++        return Err(UnorderedPsbtError::UnorderedSighashSingle);
 +    }
 +    if let Some(seed) = global.sort_seed()
 +        && seed.len() < SortSeed::MIN_LEN
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 +    {
 +        return Err(UnorderedPsbtError::OutputSortKeyTooLong(index));
 +    }
-+    Ok(())
++    match global.sort_key_derivation() {
++        Some(0x00) if global.sort_seed().is_some() => {
++            return Err(UnorderedPsbtError::UnexpectedSortSeed);
++        }
++        Some(0x01) => {
++            if let Some(input) = psbt.inputs.iter().find(|input| input.sort_key().is_some()) {
++                return Err(UnorderedPsbtError::UnexpectedInputSortKey(out_point(input)));
++            }
++            if let Some(index) = psbt
++                .outputs
++                .iter()
++                .position(|output| output.sort_key().is_some())
++            {
++                return Err(UnorderedPsbtError::UnexpectedOutputSortKey(index));
++            }
++        }
++        _ => {}
++    }
++    duplicate_sort_key(psbt.inputs.iter().filter_map(|input| input.sort_key()))
++        .or_else(|| duplicate_sort_key(psbt.outputs.iter().filter_map(|output| output.sort_key())))
++        .map_or(Ok(()), |key| {
++            Err(UnorderedPsbtError::DuplicateSortKey(key.to_vec()))
++        })
++}
++
++/// The first sort key that repeats, if any.
++fn duplicate_sort_key<'a>(mut keys: impl Iterator<Item = &'a [u8]>) -> Option<&'a [u8]> {
++    let mut seen = std::collections::HashSet::new();
++    keys.find(|key| !seen.insert(*key))
 +}
  
- impl UnorderedPsbt {
-     /// Freeze the inputs or outputs whose `tx_modifiable_flags` bit is clear.
+ /// The declared count and set size, if they disagree.
+ fn count_mismatch(declared: usize, len: usize) -> Option<Conflict<usize>> {
 @@ crates/concurrent-psbt/src/psbt/tx.rs: impl ResultUnorderedPsbt {
      /// Joining by outpoint and unique ID is for merging copies of a PSBT, not
      /// for entries within one.
      ///
-+    /// A PSBT whose inputs or outputs are modifiable must be marked unordered,
-+    /// since its order would otherwise be lost. A PSBT that is not modifiable
-+    /// may be ordered: joining it only updates the inputs and outputs it has.
++    /// The PSBT must be marked unordered, since reading an ordered PSBT as
++    /// unordered would discard its order.
 +    ///
      /// # Errors
 -    /// Returns the first input whose outpoint repeats, then the first output
 -    /// that is missing a `PSBT_OUT_UNIQUE_ID` field, has one longer than
 -    /// [`UniqueId::MAX_LEN`] bytes, or repeats one.
-+    /// Returns [`UnorderedPsbtError::InvalidUnorderedFlag`] or
-+    /// [`UnorderedPsbtError::InvalidSortDeterministic`] for a malformed flag,
-+    /// [`UnorderedPsbtError::OrderedModifiable`] for a modifiable PSBT that is
-+    /// not unordered, and [`UnorderedPsbtError::UnorderedSighashSingle`] for an
-+    /// unordered PSBT with the `SIGHASH_SINGLE` flag. Then returns
-+    /// [`UnorderedPsbtError::SortSeedTooShort`] for a short sort seed and
++    /// Returns [`UnorderedPsbtError::NotUnordered`] for an ordered PSBT,
++    /// [`UnorderedPsbtError::InvalidUnorderedFlag`] or
++    /// [`UnorderedPsbtError::InvalidSortKeyDerivation`] for a malformed flag,
++    /// and [`UnorderedPsbtError::UnorderedSighashSingle`] for the
++    /// `SIGHASH_SINGLE` flag. Then returns
++    /// [`UnorderedPsbtError::SortSeedTooShort`] for a short sort seed,
 +    /// [`UnorderedPsbtError::InputSortKeyTooLong`] or
 +    /// [`UnorderedPsbtError::OutputSortKeyTooLong`] for the first long sort
++    /// key, [`UnorderedPsbtError::UnexpectedSortSeed`],
++    /// [`UnorderedPsbtError::UnexpectedInputSortKey`] or
++    /// [`UnorderedPsbtError::UnexpectedOutputSortKey`] for a sort field that
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` rules out, and
++    /// [`UnorderedPsbtError::DuplicateSortKey`] for the first repeated sort
 +    /// key. Then returns the first input whose outpoint repeats, then the
 +    /// first output that is missing a `PSBT_OUT_UNIQUE_ID` field, has one
 +    /// longer than [`UniqueId::MAX_LEN`] bytes, or repeats one.
      pub fn try_from_psbt(psbt: Psbt) -> Result<Self, UnorderedPsbtError> {
 +        validate_unordered(&psbt)?;
-         let inputs = InputSet::try_from_inputs(psbt.inputs)?;
-         let outputs = OutputSet::try_from_outputs(psbt.outputs)?;
+         // A set that is not modifiable is frozen, so it joins only with an
+         // identical set.
+         let flags = psbt.global.tx_modifiable_flags;
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+     use super::*;
+     use crate::lattice::join::Join;
+ 
++    /// A default [`Global`] marked unordered.
++    fn unordered_global() -> Global {
++        let mut global = Global::default();
++        global.set_unordered();
++        global
++    }
++
+     #[cfg(any(feature = "unit-tests", feature = "prop-tests"))]
+     #[test]
+     fn join_flags_preexisting_count_mismatch() {
+         let empty = || UnorderedPsbt {
+-            global: Global::default(),
++            global: unordered_global(),
+             inputs: InputSet::default(),
+             outputs: OutputSet::default(),
+         };
+         let inconsistent = ResultUnorderedPsbt::try_from_psbt(Psbt {
+             global: Global {
+                 input_count: 1,
+-                ..Global::default()
++                ..unordered_global()
+             },
+             inputs: vec![],
+             outputs: vec![],
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
  
+         fn make_unordered_psbt() -> UnorderedPsbt {
+             UnorderedPsbt {
+-                global: Global::default(),
++                global: unordered_global(),
+                 inputs: InputSet::default(),
+                 outputs: OutputSet::default(),
+             }
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                  conflict.to_string(),
                  "unordered PSBT contains conflicting fields"
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                "PSBT_GLOBAL_TX_UNORDERED is [01], not 0x03"
 +            );
 +            assert_eq!(
-+                UnorderedPsbtError::InvalidSortDeterministic(vec![2, 0]).to_string(),
-+                "PSBT_GLOBAL_SORT_DETERMINISTIC is [02, 00], not 0x00 or 0x01"
++                UnorderedPsbtError::InvalidSortKeyDerivation(vec![2, 0]).to_string(),
++                "PSBT_GLOBAL_SORT_KEY_DERIVATION is [02, 00], not 0x00 or 0x01"
 +            );
 +            assert_eq!(
-+                UnorderedPsbtError::OrderedModifiable.to_string(),
-+                "PSBT is modifiable but not marked unordered"
++                UnorderedPsbtError::NotUnordered.to_string(),
++                "PSBT is not marked unordered"
 +            );
 +            assert_eq!(
 +                UnorderedPsbtError::UnorderedSighashSingle.to_string(),
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +        #[test]
 +        fn try_from_psbt_rejects_malformed_flags() {
 +            let with_field = |subtype, value: Vec<u8>| {
-+                let mut global = Global::default();
++                let mut global = unordered_global();
 +                global.proprietaries.insert(
 +                    psbt_v2::raw::ProprietaryKey {
 +                        prefix: crate::PROPRIETARY_PREFIX.to_vec(),
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                Err(UnorderedPsbtError::InvalidUnorderedFlag(vec![0x01]))
 +            );
 +            assert_eq!(
-+                with_field(PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE, vec![0x01, 0x00]),
-+                Err(UnorderedPsbtError::InvalidSortDeterministic(vec![
++                with_field(PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE, vec![0x01, 0x00]),
++                Err(UnorderedPsbtError::InvalidSortKeyDerivation(vec![
 +                    0x01, 0x00
 +                ]))
 +            );
-+            assert!(with_field(PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE, vec![0x00]).is_ok());
-+            assert!(with_field(PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE, vec![0x01]).is_ok());
++            assert!(with_field(PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE, vec![0x00]).is_ok());
++            assert!(with_field(PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE, vec![0x01]).is_ok());
          }
  
          #[test]
+         fn try_from_psbt_no_uid_err() {
+             let psbt = Psbt {
+-                global: Global::default(),
++                global: unordered_global(),
+                 inputs: vec![],
+                 outputs: vec![Output::default()],
+             };
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+         #[test]
+         fn result_try_from_psbt_no_uid_err() {
+             let psbt = Psbt {
+-                global: Global::default(),
++                global: unordered_global(),
+                 inputs: vec![],
+                 outputs: vec![Output::default()],
+             };
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+             let psbt = Psbt {
+                 global: Global {
+                     input_count: 2,
+-                    ..Global::default()
++                    ..unordered_global()
+                 },
+                 inputs: vec![a, b],
+                 outputs: vec![],
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+             let psbt = Psbt {
+                 global: Global {
+                     output_count: 2,
+-                    ..Global::default()
++                    ..unordered_global()
+                 },
+                 inputs: vec![],
+                 outputs: vec![output_with_uid(&[1], 1000), output_with_uid(&[1], 2000)],
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+         fn result_try_from_psbt_consistent_counts_ok() {
+             // Counts match → no conflict
+             let psbt = Psbt {
+-                global: Global::default(), // input_count=0, output_count=0
++                global: unordered_global(), // input_count=0, output_count=0
+                 inputs: vec![],
+                 outputs: vec![],
+             };
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
-             output.proprietaries.insert(key, vec![txid_byte; 16]);
-             let outputs = OutputSet::try_from_outputs([output]).unwrap();
- 
-+            let mut global = Global {
-+                tx_modifiable_flags: INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE,
-+                ..Global::default()
-+            };
-+            global.set_unordered();
              UnorderedPsbt {
--                global: Global {
--                    tx_modifiable_flags: INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE,
+                 global: Global {
+                     tx_modifiable_flags: INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE,
 -                    ..Global::default()
--                },
-+                global,
++                    ..unordered_global()
+                 },
                  inputs,
                  outputs,
-             }
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
-                     }
-                     let output_set = OutputSet::try_from_outputs(outputs).expect("distinct UIDs");
- 
--                    UnorderedPsbt {
--                        global: Global {
--                            tx_version: if use_v1 {
--                                transaction::Version::ONE
--                            } else {
--                                transaction::Version::TWO
--                            },
--                            tx_modifiable_flags: flags,
--                            input_count: inputs.len(),
--                            output_count: output_set.len(),
+                                 transaction::Version::TWO
+                             },
+                             tx_modifiable_flags: flags,
 -                            ..Global::default()
-+                    let mut global = Global {
-+                        tx_version: if use_v1 {
-+                            transaction::Version::ONE
-+                        } else {
-+                            transaction::Version::TWO
++                            ..unordered_global()
                          },
-+                        tx_modifiable_flags: flags,
-+                        input_count: inputs.len(),
-+                        output_count: output_set.len(),
-+                        ..Global::default()
-+                    };
-+                    global.set_unordered();
-+                    UnorderedPsbt {
-+                        global,
                          inputs,
                          outputs: output_set,
-                     }
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                  prop_assert_eq!(joined.is_ok(), inputs_agree && outputs_agree);
              }
  
 +            #[test]
-+            fn try_from_psbt_requires_unordered_if_modifiable(
++            fn try_from_psbt_requires_unordered_without_sighash_single(
 +                flags in 0u8..8,
 +                unordered in proptest::bool::ANY,
 +            ) {
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                    global.set_unordered();
 +                }
 +                let psbt = Psbt { global, inputs: vec![], outputs: vec![] };
-+                let expected = if unordered && flags & HAS_SIGHASH_SINGLE != 0 {
++                let expected = if !unordered {
++                    Err(UnorderedPsbtError::NotUnordered)
++                } else if flags & HAS_SIGHASH_SINGLE != 0 {
 +                    Err(UnorderedPsbtError::UnorderedSighashSingle)
-+                } else if !unordered && flags & (INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE) != 0 {
-+                    Err(UnorderedPsbtError::OrderedModifiable)
 +                } else {
 +                    Ok(())
 +                };
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +            }
 +
 +            #[test]
++            fn try_from_psbt_checks_sort_fields_against_derivation(
++                derivation in proptest::option::of(0u8..2),
++                seeded in proptest::bool::ANY,
++                input_keys in proptest::collection::vec(proptest::option::of(0u8..3), 0..4),
++                output_keys in proptest::collection::vec(proptest::option::of(0u8..3), 0..4),
++            ) {
++                let mut global = unordered_global();
++                if let Some(mode) = derivation {
++                    global.set_sort_key_derivation(mode);
++                }
++                if seeded {
++                    global.set_sort_seed(SortSeed::try_from(vec![0; 16]).expect("16 bytes"));
++                }
++                let outpoint = |vout| OutPoint { vout, ..OutPoint::null() };
++                let inputs: Vec<_> = (0u32..)
++                    .zip(&input_keys)
++                    .map(|(vout, key)| {
++                        let mut input = psbt_v2::v2::Input::new(&outpoint(vout));
++                        if let Some(key) = key {
++                            input.set_sort_key(SortKey::try_from(vec![*key]).expect("short"));
++                        }
++                        input
++                    })
++                    .collect();
++                let outputs: Vec<_> = (0u8..)
++                    .zip(&output_keys)
++                    .map(|(uid, key)| {
++                        let mut output = Output::default();
++                        output.set_unique_id(UniqueId::new(vec![uid]));
++                        if let Some(key) = key {
++                            output.set_sort_key(SortKey::try_from(vec![*key]).expect("short"));
++                        }
++                        output
++                    })
++                    .collect();
++                let psbt = Psbt {
++                    global: Global { input_count: inputs.len(), output_count: outputs.len(), ..global },
++                    inputs,
++                    outputs,
++                };
++                let first_repeat = |keys: &[Option<u8>]| {
++                    let keys: Vec<u8> = keys.iter().flatten().copied().collect();
++                    keys.iter()
++                        .enumerate()
++                        .find(|&(i, key)| keys[..i].contains(key))
++                        .map(|(_, key)| vec![*key])
++                };
++                let input_key = input_keys.iter().position(Option::is_some);
++                let output_key = output_keys.iter().position(Option::is_some);
++                let expected = match derivation {
++                    Some(0) if seeded => Err(UnorderedPsbtError::UnexpectedSortSeed),
++                    Some(1) if input_key.is_some() => Err(UnorderedPsbtError::UnexpectedInputSortKey(
++                        outpoint(u32::try_from(input_key.unwrap()).unwrap()),
++                    )),
++                    Some(1) if output_key.is_some() => {
++                        Err(UnorderedPsbtError::UnexpectedOutputSortKey(output_key.unwrap()))
++                    }
++                    _ => match first_repeat(&input_keys).or_else(|| first_repeat(&output_keys)) {
++                        Some(key) => Err(UnorderedPsbtError::DuplicateSortKey(key)),
++                        None => Ok(()),
++                    },
++                };
++                prop_assert_eq!(ResultUnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
++            }
++
++            #[test]
 +            fn try_from_psbt_bounds_sort_field_sizes(
 +                seed_len in proptest::option::of(0usize..=24),
 +                input_key_len in proptest::option::of(0usize..=40),
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                    subtype,
 +                    key: vec![],
 +                };
-+                let mut global = Global::default();
++                let mut global = unordered_global();
 +                let mut input = psbt_v2::v2::Input::new(&OutPoint::null());
 +                let mut output = Output::default();
 +                output.set_unique_id(UniqueId::new(vec![1]));
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +            #[test]
 +            fn try_from_psbt_validates_flag_values(
 +                unordered in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
-+                deterministic in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
++                derivation in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
 +            ) {
 +                let mut global = Global::default();
 +                for (subtype, value) in [
 +                    (PSBT_GLOBAL_TX_UNORDERED_SUBTYPE, &unordered),
-+                    (PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE, &deterministic),
++                    (PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE, &derivation),
 +                ] {
 +                    if let Some(value) = value {
 +                        global.proprietaries.insert(
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                    }
 +                }
 +                let psbt = Psbt { global, inputs: vec![], outputs: vec![] };
-+                let expected = match (unordered, deterministic) {
++                let expected = match (unordered, derivation) {
++                    (None, _) => Err(UnorderedPsbtError::NotUnordered),
 +                    (Some(value), _) if value != [0x03] => {
 +                        Err(UnorderedPsbtError::InvalidUnorderedFlag(value))
 +                    }
 +                    (_, Some(value)) if value != [0x00] && value != [0x01] => {
-+                        Err(UnorderedPsbtError::InvalidSortDeterministic(value))
++                        Err(UnorderedPsbtError::InvalidSortKeyDerivation(value))
 +                    }
 +                    _ => Ok(()),
 +                };
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                        format!("{value:02x?}"),
 +                    ),
 +                    (
-+                        UnorderedPsbtError::InvalidSortDeterministic(value.clone()),
++                        UnorderedPsbtError::InvalidSortKeyDerivation(value.clone()),
 +                        format!("{value:02x?}"),
 +                    ),
-+                    (UnorderedPsbtError::OrderedModifiable, String::new()),
++                    (UnorderedPsbtError::NotUnordered, String::new()),
 +                    (UnorderedPsbtError::UnorderedSighashSingle, String::new()),
 +                    (UnorderedPsbtError::SortSeedTooShort(len), len.to_string()),
 +                    (UnorderedPsbtError::InputSortKeyTooLong(outpoint), outpoint.to_string()),
 +                    (UnorderedPsbtError::OutputSortKeyTooLong(index), index.to_string()),
++                    (UnorderedPsbtError::UnexpectedSortSeed, String::new()),
++                    (UnorderedPsbtError::UnexpectedInputSortKey(outpoint), outpoint.to_string()),
++                    (UnorderedPsbtError::UnexpectedOutputSortKey(index), index.to_string()),
++                    (UnorderedPsbtError::DuplicateSortKey(value.clone()), format!("{value:02x?}")),
 +                ];
 +                let messages: Vec<_> = errors.iter().map(|(error, _)| error.to_string()).collect();
 +                for ((_, payload), message) in errors.iter().zip(&messages) {
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
              #[test]
              fn is_ok_try_unwrap_consistent(r in arb_result_unordered_psbt()) {
                  if r.is_ok() {
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+                     global: Global {
+                         input_count,
+                         output_count,
+-                        ..Global::default()
++                        ..unordered_global()
+                     },
+                     inputs: vec![],
+                     outputs: vec![],
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+                 let psbt = Psbt {
+                     global: Global {
+                         input_count: outpoints.len(),
+-                        ..Global::default()
++                        ..unordered_global()
+                     },
+                     inputs: outpoints.iter().map(psbt_v2::v2::Input::new).collect(),
+                     outputs: vec![],
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+                 let psbt = Psbt {
+                     global: Global {
+                         output_count: outputs.len(),
+-                        ..Global::default()
++                        ..unordered_global()
+                     },
+                     inputs: vec![],
+                     outputs,

@github-actions

Copy link
Copy Markdown
range-diff for force push a0900aeb14 → 568bc715d0 November 14, 2026 04:12 UTC: 1 modified; 1 commit; base fc9b919e82 → 86a484d169 (diverged, 2 ahead and 2 behind)

reproduce: git range-diff fc9b919..a0900ae 86a484d..568bc71

1:  a0900aeb14 +358 -24 1f ! 1:  568bc715d0 +482 -22 1f reject malformed unordered PSBTs
1: a0900aeb14 ! 1: 568bc715d0 reject malformed unordered PSBTs
@@ crates/concurrent-psbt/src/psbt/tx.rs: use psbt_v2::v2::{Global, Psbt};
 -use super::input::{DuplicateInput, InputSet, ResultInputSet};
 -use super::output::{OutputSet, OutputSetError, ResultOutputSet, UniqueId};
 +use super::global::{
-+    GlobalExt, GlobalSortExt, PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE,
++    GlobalExt, GlobalSortExt, PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE,
 +    PSBT_GLOBAL_TX_UNORDERED_SUBTYPE, ResultGlobal, SortSeed,
 +};
 +use super::input::{DuplicateInput, InputSet, InputSortKeyExt, ResultInputSet, SortKey, out_point};
@@ crates/concurrent-psbt/src/psbt/tx.rs: pub enum UnorderedPsbtError {
      Conflict(Box<ResultUnorderedPsbt>),
 +    /// `PSBT_GLOBAL_TX_UNORDERED` is present but its value is not `0x03`.
 +    InvalidUnorderedFlag(Vec<u8>),
-+    /// `PSBT_GLOBAL_SORT_DETERMINISTIC` is present but its value is neither
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` is present but its value is neither
 +    /// `0x00` nor `0x01`.
-+    InvalidSortDeterministic(Vec<u8>),
-+    /// Inputs or outputs are modifiable but the PSBT is ordered. Reading it as
-+    /// unordered would discard its order.
-+    OrderedModifiable,
++    InvalidSortKeyDerivation(Vec<u8>),
++    /// `PSBT_GLOBAL_TX_UNORDERED` is absent, so the PSBT is ordered. Reading
++    /// it as unordered would discard its order.
++    NotUnordered,
 +    /// The PSBT is unordered but `tx_modifiable_flags` has the
 +    /// `Has SIGHASH_SINGLE` bit set.
 +    UnorderedSighashSingle,
@@ crates/concurrent-psbt/src/psbt/tx.rs: pub enum UnorderedPsbtError {
 +    /// The output at this position has a `PSBT_OUT_SORT_KEY` longer than
 +    /// [`SortKey::MAX_LEN`].
 +    OutputSortKeyTooLong(usize),
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` is `0x00`, so sort keys are never
++    /// derived, but `PSBT_GLOBAL_SORT_SEED` is set.
++    UnexpectedSortSeed,
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` is `0x01`, so every sort key is
++    /// derived, but the input spending this outpoint has a `PSBT_IN_SORT_KEY`.
++    UnexpectedInputSortKey(OutPoint),
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` is `0x01`, so every sort key is
++    /// derived, but the output at this position has a `PSBT_OUT_SORT_KEY`.
++    UnexpectedOutputSortKey(usize),
++    /// Two inputs, or two outputs, have this explicit sort key.
++    DuplicateSortKey(Vec<u8>),
  }
  
  impl From<DuplicateInput> for UnorderedPsbtError {
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl fmt::Display for UnorderedPsbtError
 +            Self::InvalidUnorderedFlag(value) => {
 +                write!(f, "PSBT_GLOBAL_TX_UNORDERED is {value:02x?}, not 0x03")
 +            }
-+            Self::InvalidSortDeterministic(value) => write!(
++            Self::InvalidSortKeyDerivation(value) => write!(
 +                f,
-+                "PSBT_GLOBAL_SORT_DETERMINISTIC is {value:02x?}, not 0x00 or 0x01"
++                "PSBT_GLOBAL_SORT_KEY_DERIVATION is {value:02x?}, not 0x00 or 0x01"
 +            ),
-+            Self::OrderedModifiable => {
-+                write!(f, "PSBT is modifiable but not marked unordered")
-+            }
++            Self::NotUnordered => write!(f, "PSBT is not marked unordered"),
 +            Self::UnorderedSighashSingle => {
 +                write!(f, "unordered PSBT has the SIGHASH_SINGLE flag set")
 +            }
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl fmt::Display for UnorderedPsbtError
 +                "sort key of output {index} is longer than {} bytes",
 +                SortKey::MAX_LEN
 +            ),
++            Self::UnexpectedSortSeed => write!(
++                f,
++                "PSBT_GLOBAL_SORT_SEED is set but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x00"
++            ),
++            Self::UnexpectedInputSortKey(outpoint) => write!(
++                f,
++                "the input spending {outpoint} has a sort key but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x01"
++            ),
++            Self::UnexpectedOutputSortKey(index) => write!(
++                f,
++                "output {index} has a sort key but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x01"
++            ),
++            Self::DuplicateSortKey(key) => write!(f, "duplicate sort key {key:02x?}"),
          }
      }
  }
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 -    /// outpoint or unique ID, or an output missing `PSBT_OUT_UNIQUE_ID` or
 -    /// with a long one), or
 +    /// Returns the errors of [`ResultUnorderedPsbt::try_from_psbt`] (malformed
-+    /// unordered flags, an ordered modifiable PSBT, a repeated outpoint or
++    /// unordered flags, an ordered PSBT, a repeated outpoint or
 +    /// unique ID, or an output missing `PSBT_OUT_UNIQUE_ID` or with a long
 +    /// one), or
      /// [`UnorderedPsbtError::Conflict`] if the declared counts disagree with
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 +    global.proprietaries.get(&key).map(Vec::as_slice)
 +}
 +
-+/// Check that a PSBT can be read as unordered: its unordered and
-+/// deterministic flags are well formed, it is unordered if anything is
-+/// modifiable, an unordered PSBT does not use `SIGHASH_SINGLE`, and its sort
-+/// seed and sort keys have valid sizes.
++/// Check that a PSBT can be read as unordered: it is marked unordered, its
++/// flags are well formed, it does not use `SIGHASH_SINGLE`, its sort seed and
++/// sort keys have valid sizes, the sort fields present agree with
++/// `PSBT_GLOBAL_SORT_KEY_DERIVATION`, and no two inputs or two outputs share an
++/// explicit sort key.
 +fn validate_unordered(psbt: &Psbt) -> Result<(), UnorderedPsbtError> {
 +    let global = &psbt.global;
-+    if let Some(value) = proprietary_value(global, PSBT_GLOBAL_TX_UNORDERED_SUBTYPE)
-+        && value != [0x03]
-+    {
-+        return Err(UnorderedPsbtError::InvalidUnorderedFlag(value.to_vec()));
++    match proprietary_value(global, PSBT_GLOBAL_TX_UNORDERED_SUBTYPE) {
++        None => return Err(UnorderedPsbtError::NotUnordered),
++        Some(value) if value != [0x03] => {
++            return Err(UnorderedPsbtError::InvalidUnorderedFlag(value.to_vec()));
++        }
++        Some(_) => {}
 +    }
-+    if let Some(value) = proprietary_value(global, PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE)
++    if let Some(value) = proprietary_value(global, PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE)
 +        && value != [0x00]
 +        && value != [0x01]
 +    {
-+        return Err(UnorderedPsbtError::InvalidSortDeterministic(value.to_vec()));
++        return Err(UnorderedPsbtError::InvalidSortKeyDerivation(value.to_vec()));
 +    }
-+    let flags = global.tx_modifiable_flags;
-+    if global.is_unordered() {
-+        if flags & HAS_SIGHASH_SINGLE != 0 {
-+            return Err(UnorderedPsbtError::UnorderedSighashSingle);
-+        }
-+    } else if flags & (INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE) != 0 {
-+        return Err(UnorderedPsbtError::OrderedModifiable);
++    if global.tx_modifiable_flags & HAS_SIGHASH_SINGLE != 0 {
++        return Err(UnorderedPsbtError::UnorderedSighashSingle);
 +    }
 +    if let Some(seed) = global.sort_seed()
 +        && seed.len() < SortSeed::MIN_LEN
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 +    {
 +        return Err(UnorderedPsbtError::OutputSortKeyTooLong(index));
 +    }
-+    Ok(())
++    match global.sort_key_derivation() {
++        Some(0x00) if global.sort_seed().is_some() => {
++            return Err(UnorderedPsbtError::UnexpectedSortSeed);
++        }
++        Some(0x01) => {
++            if let Some(input) = psbt.inputs.iter().find(|input| input.sort_key().is_some()) {
++                return Err(UnorderedPsbtError::UnexpectedInputSortKey(out_point(input)));
++            }
++            if let Some(index) = psbt
++                .outputs
++                .iter()
++                .position(|output| output.sort_key().is_some())
++            {
++                return Err(UnorderedPsbtError::UnexpectedOutputSortKey(index));
++            }
++        }
++        _ => {}
++    }
++    duplicate_sort_key(psbt.inputs.iter().filter_map(|input| input.sort_key()))
++        .or_else(|| duplicate_sort_key(psbt.outputs.iter().filter_map(|output| output.sort_key())))
++        .map_or(Ok(()), |key| {
++            Err(UnorderedPsbtError::DuplicateSortKey(key.to_vec()))
++        })
++}
++
++/// The first sort key that repeats, if any.
++fn duplicate_sort_key<'a>(mut keys: impl Iterator<Item = &'a [u8]>) -> Option<&'a [u8]> {
++    let mut seen = std::collections::HashSet::new();
++    keys.find(|key| !seen.insert(*key))
 +}
  
- impl UnorderedPsbt {
-     /// Freeze the inputs or outputs whose `tx_modifiable_flags` bit is clear.
+ /// The declared count and set size, if they disagree.
+ fn count_mismatch(declared: usize, len: usize) -> Option<Conflict<usize>> {
 @@ crates/concurrent-psbt/src/psbt/tx.rs: impl ResultUnorderedPsbt {
      /// Joining by outpoint and unique ID is for merging copies of a PSBT, not
      /// for entries within one.
      ///
-+    /// A PSBT whose inputs or outputs are modifiable must be marked unordered,
-+    /// since its order would otherwise be lost. A PSBT that is not modifiable
-+    /// may be ordered: joining it only updates the inputs and outputs it has.
++    /// The PSBT must be marked unordered, since reading an ordered PSBT as
++    /// unordered would discard its order.
 +    ///
      /// # Errors
 -    /// Returns the first input whose outpoint repeats, then the first output
 -    /// that is missing a `PSBT_OUT_UNIQUE_ID` field, has one longer than
 -    /// [`UniqueId::MAX_LEN`] bytes, or repeats one.
-+    /// Returns [`UnorderedPsbtError::InvalidUnorderedFlag`] or
-+    /// [`UnorderedPsbtError::InvalidSortDeterministic`] for a malformed flag,
-+    /// [`UnorderedPsbtError::OrderedModifiable`] for a modifiable PSBT that is
-+    /// not unordered, and [`UnorderedPsbtError::UnorderedSighashSingle`] for an
-+    /// unordered PSBT with the `SIGHASH_SINGLE` flag. Then returns
-+    /// [`UnorderedPsbtError::SortSeedTooShort`] for a short sort seed and
++    /// Returns [`UnorderedPsbtError::NotUnordered`] for an ordered PSBT,
++    /// [`UnorderedPsbtError::InvalidUnorderedFlag`] or
++    /// [`UnorderedPsbtError::InvalidSortKeyDerivation`] for a malformed flag,
++    /// and [`UnorderedPsbtError::UnorderedSighashSingle`] for the
++    /// `SIGHASH_SINGLE` flag. Then returns
++    /// [`UnorderedPsbtError::SortSeedTooShort`] for a short sort seed,
 +    /// [`UnorderedPsbtError::InputSortKeyTooLong`] or
 +    /// [`UnorderedPsbtError::OutputSortKeyTooLong`] for the first long sort
++    /// key, [`UnorderedPsbtError::UnexpectedSortSeed`],
++    /// [`UnorderedPsbtError::UnexpectedInputSortKey`] or
++    /// [`UnorderedPsbtError::UnexpectedOutputSortKey`] for a sort field that
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` rules out, and
++    /// [`UnorderedPsbtError::DuplicateSortKey`] for the first repeated sort
 +    /// key. Then returns the first input whose outpoint repeats, then the
 +    /// first output that is missing a `PSBT_OUT_UNIQUE_ID` field, has one
 +    /// longer than [`UniqueId::MAX_LEN`] bytes, or repeats one.
      pub fn try_from_psbt(psbt: Psbt) -> Result<Self, UnorderedPsbtError> {
 +        validate_unordered(&psbt)?;
-         let inputs = InputSet::try_from_inputs(psbt.inputs)?;
-         let outputs = OutputSet::try_from_outputs(psbt.outputs)?;
+         // A set that is not modifiable is frozen, so it joins only with an
+         // identical set.
+         let flags = psbt.global.tx_modifiable_flags;
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+     use super::*;
+     use crate::lattice::join::Join;
+ 
++    /// A default [`Global`] marked unordered.
++    fn unordered_global() -> Global {
++        let mut global = Global::default();
++        global.set_unordered();
++        global
++    }
++
+     #[cfg(any(feature = "unit-tests", feature = "prop-tests"))]
+     #[test]
+     fn join_flags_preexisting_count_mismatch() {
+         let empty = || UnorderedPsbt {
+-            global: Global::default(),
++            global: unordered_global(),
+             inputs: InputSet::default(),
+             outputs: OutputSet::default(),
+         };
+         let inconsistent = ResultUnorderedPsbt::try_from_psbt(Psbt {
+             global: Global {
+                 input_count: 1,
+-                ..Global::default()
++                ..unordered_global()
+             },
+             inputs: vec![],
+             outputs: vec![],
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
  
+         fn make_unordered_psbt() -> UnorderedPsbt {
+             UnorderedPsbt {
+-                global: Global::default(),
++                global: unordered_global(),
+                 inputs: InputSet::default(),
+                 outputs: OutputSet::default(),
+             }
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                  conflict.to_string(),
                  "unordered PSBT contains conflicting fields"
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                "PSBT_GLOBAL_TX_UNORDERED is [01], not 0x03"
 +            );
 +            assert_eq!(
-+                UnorderedPsbtError::InvalidSortDeterministic(vec![2, 0]).to_string(),
-+                "PSBT_GLOBAL_SORT_DETERMINISTIC is [02, 00], not 0x00 or 0x01"
++                UnorderedPsbtError::InvalidSortKeyDerivation(vec![2, 0]).to_string(),
++                "PSBT_GLOBAL_SORT_KEY_DERIVATION is [02, 00], not 0x00 or 0x01"
 +            );
 +            assert_eq!(
-+                UnorderedPsbtError::OrderedModifiable.to_string(),
-+                "PSBT is modifiable but not marked unordered"
++                UnorderedPsbtError::NotUnordered.to_string(),
++                "PSBT is not marked unordered"
 +            );
 +            assert_eq!(
 +                UnorderedPsbtError::UnorderedSighashSingle.to_string(),
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +        #[test]
 +        fn try_from_psbt_rejects_malformed_flags() {
 +            let with_field = |subtype, value: Vec<u8>| {
-+                let mut global = Global::default();
++                let mut global = unordered_global();
 +                global.proprietaries.insert(
 +                    psbt_v2::raw::ProprietaryKey {
 +                        prefix: crate::PROPRIETARY_PREFIX.to_vec(),
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                Err(UnorderedPsbtError::InvalidUnorderedFlag(vec![0x01]))
 +            );
 +            assert_eq!(
-+                with_field(PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE, vec![0x01, 0x00]),
-+                Err(UnorderedPsbtError::InvalidSortDeterministic(vec![
++                with_field(PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE, vec![0x01, 0x00]),
++                Err(UnorderedPsbtError::InvalidSortKeyDerivation(vec![
 +                    0x01, 0x00
 +                ]))
 +            );
-+            assert!(with_field(PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE, vec![0x00]).is_ok());
-+            assert!(with_field(PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE, vec![0x01]).is_ok());
++            assert!(with_field(PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE, vec![0x00]).is_ok());
++            assert!(with_field(PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE, vec![0x01]).is_ok());
          }
  
          #[test]
+         fn try_from_psbt_no_uid_err() {
+             let psbt = Psbt {
+-                global: Global::default(),
++                global: unordered_global(),
+                 inputs: vec![],
+                 outputs: vec![Output::default()],
+             };
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+         #[test]
+         fn result_try_from_psbt_no_uid_err() {
+             let psbt = Psbt {
+-                global: Global::default(),
++                global: unordered_global(),
+                 inputs: vec![],
+                 outputs: vec![Output::default()],
+             };
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+             let psbt = Psbt {
+                 global: Global {
+                     input_count: 2,
+-                    ..Global::default()
++                    ..unordered_global()
+                 },
+                 inputs: vec![a, b],
+                 outputs: vec![],
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+             let psbt = Psbt {
+                 global: Global {
+                     output_count: 2,
+-                    ..Global::default()
++                    ..unordered_global()
+                 },
+                 inputs: vec![],
+                 outputs: vec![output_with_uid(&[1], 1000), output_with_uid(&[1], 2000)],
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+         fn result_try_from_psbt_consistent_counts_ok() {
+             // Counts match → no conflict
+             let psbt = Psbt {
+-                global: Global::default(), // input_count=0, output_count=0
++                global: unordered_global(), // input_count=0, output_count=0
+                 inputs: vec![],
+                 outputs: vec![],
+             };
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
-             output.proprietaries.insert(key, vec![txid_byte; 16]);
-             let outputs = OutputSet::try_from_outputs([output]).unwrap();
- 
-+            let mut global = Global {
-+                tx_modifiable_flags: INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE,
-+                ..Global::default()
-+            };
-+            global.set_unordered();
              UnorderedPsbt {
--                global: Global {
--                    tx_modifiable_flags: INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE,
+                 global: Global {
+                     tx_modifiable_flags: INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE,
 -                    ..Global::default()
--                },
-+                global,
++                    ..unordered_global()
+                 },
                  inputs,
                  outputs,
-             }
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
-                     }
-                     let output_set = OutputSet::try_from_outputs(outputs).expect("distinct UIDs");
- 
--                    UnorderedPsbt {
--                        global: Global {
--                            tx_version: if use_v1 {
--                                transaction::Version::ONE
--                            } else {
--                                transaction::Version::TWO
--                            },
--                            tx_modifiable_flags: flags,
--                            input_count: inputs.len(),
--                            output_count: output_set.len(),
+                                 transaction::Version::TWO
+                             },
+                             tx_modifiable_flags: flags,
 -                            ..Global::default()
-+                    let mut global = Global {
-+                        tx_version: if use_v1 {
-+                            transaction::Version::ONE
-+                        } else {
-+                            transaction::Version::TWO
++                            ..unordered_global()
                          },
-+                        tx_modifiable_flags: flags,
-+                        input_count: inputs.len(),
-+                        output_count: output_set.len(),
-+                        ..Global::default()
-+                    };
-+                    global.set_unordered();
-+                    UnorderedPsbt {
-+                        global,
                          inputs,
                          outputs: output_set,
-                     }
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                  prop_assert_eq!(joined.is_ok(), inputs_agree && outputs_agree);
              }
  
 +            #[test]
-+            fn try_from_psbt_requires_unordered_if_modifiable(
++            fn try_from_psbt_requires_unordered_without_sighash_single(
 +                flags in 0u8..8,
 +                unordered in proptest::bool::ANY,
 +            ) {
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                    global.set_unordered();
 +                }
 +                let psbt = Psbt { global, inputs: vec![], outputs: vec![] };
-+                let expected = if unordered && flags & HAS_SIGHASH_SINGLE != 0 {
++                let expected = if !unordered {
++                    Err(UnorderedPsbtError::NotUnordered)
++                } else if flags & HAS_SIGHASH_SINGLE != 0 {
 +                    Err(UnorderedPsbtError::UnorderedSighashSingle)
-+                } else if !unordered && flags & (INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE) != 0 {
-+                    Err(UnorderedPsbtError::OrderedModifiable)
 +                } else {
 +                    Ok(())
 +                };
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +            }
 +
 +            #[test]
++            fn try_from_psbt_checks_sort_fields_against_derivation(
++                derivation in proptest::option::of(0u8..2),
++                seeded in proptest::bool::ANY,
++                input_keys in proptest::collection::vec(proptest::option::of(0u8..3), 0..4),
++                output_keys in proptest::collection::vec(proptest::option::of(0u8..3), 0..4),
++            ) {
++                let mut global = unordered_global();
++                if let Some(mode) = derivation {
++                    global.set_sort_key_derivation(mode);
++                }
++                if seeded {
++                    global.set_sort_seed(SortSeed::try_from(vec![0; 16]).expect("16 bytes"));
++                }
++                let outpoint = |vout| OutPoint { vout, ..OutPoint::null() };
++                let inputs: Vec<_> = (0u32..)
++                    .zip(&input_keys)
++                    .map(|(vout, key)| {
++                        let mut input = psbt_v2::v2::Input::new(&outpoint(vout));
++                        if let Some(key) = key {
++                            input.set_sort_key(SortKey::try_from(vec![*key]).expect("short"));
++                        }
++                        input
++                    })
++                    .collect();
++                let outputs: Vec<_> = (0u8..)
++                    .zip(&output_keys)
++                    .map(|(uid, key)| {
++                        let mut output = Output::default();
++                        output.set_unique_id(UniqueId::new(vec![uid]));
++                        if let Some(key) = key {
++                            output.set_sort_key(SortKey::try_from(vec![*key]).expect("short"));
++                        }
++                        output
++                    })
++                    .collect();
++                let psbt = Psbt {
++                    global: Global { input_count: inputs.len(), output_count: outputs.len(), ..global },
++                    inputs,
++                    outputs,
++                };
++                let first_repeat = |keys: &[Option<u8>]| {
++                    let keys: Vec<u8> = keys.iter().flatten().copied().collect();
++                    keys.iter()
++                        .enumerate()
++                        .find(|&(i, key)| keys[..i].contains(key))
++                        .map(|(_, key)| vec![*key])
++                };
++                let input_key = input_keys.iter().position(Option::is_some);
++                let output_key = output_keys.iter().position(Option::is_some);
++                let expected = match derivation {
++                    Some(0) if seeded => Err(UnorderedPsbtError::UnexpectedSortSeed),
++                    Some(1) if input_key.is_some() => Err(UnorderedPsbtError::UnexpectedInputSortKey(
++                        outpoint(u32::try_from(input_key.unwrap()).unwrap()),
++                    )),
++                    Some(1) if output_key.is_some() => {
++                        Err(UnorderedPsbtError::UnexpectedOutputSortKey(output_key.unwrap()))
++                    }
++                    _ => match first_repeat(&input_keys).or_else(|| first_repeat(&output_keys)) {
++                        Some(key) => Err(UnorderedPsbtError::DuplicateSortKey(key)),
++                        None => Ok(()),
++                    },
++                };
++                prop_assert_eq!(ResultUnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
++            }
++
++            #[test]
 +            fn try_from_psbt_bounds_sort_field_sizes(
 +                seed_len in proptest::option::of(0usize..=24),
 +                input_key_len in proptest::option::of(0usize..=40),
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                    subtype,
 +                    key: vec![],
 +                };
-+                let mut global = Global::default();
++                let mut global = unordered_global();
 +                let mut input = psbt_v2::v2::Input::new(&OutPoint::null());
 +                let mut output = Output::default();
 +                output.set_unique_id(UniqueId::new(vec![1]));
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +            #[test]
 +            fn try_from_psbt_validates_flag_values(
 +                unordered in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
-+                deterministic in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
++                derivation in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
 +            ) {
 +                let mut global = Global::default();
 +                for (subtype, value) in [
 +                    (PSBT_GLOBAL_TX_UNORDERED_SUBTYPE, &unordered),
-+                    (PSBT_GLOBAL_SORT_DETERMINISTIC_SUBTYPE, &deterministic),
++                    (PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE, &derivation),
 +                ] {
 +                    if let Some(value) = value {
 +                        global.proprietaries.insert(
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                    }
 +                }
 +                let psbt = Psbt { global, inputs: vec![], outputs: vec![] };
-+                let expected = match (unordered, deterministic) {
++                let expected = match (unordered, derivation) {
++                    (None, _) => Err(UnorderedPsbtError::NotUnordered),
 +                    (Some(value), _) if value != [0x03] => {
 +                        Err(UnorderedPsbtError::InvalidUnorderedFlag(value))
 +                    }
 +                    (_, Some(value)) if value != [0x00] && value != [0x01] => {
-+                        Err(UnorderedPsbtError::InvalidSortDeterministic(value))
++                        Err(UnorderedPsbtError::InvalidSortKeyDerivation(value))
 +                    }
 +                    _ => Ok(()),
 +                };
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                        format!("{value:02x?}"),
 +                    ),
 +                    (
-+                        UnorderedPsbtError::InvalidSortDeterministic(value.clone()),
++                        UnorderedPsbtError::InvalidSortKeyDerivation(value.clone()),
 +                        format!("{value:02x?}"),
 +                    ),
-+                    (UnorderedPsbtError::OrderedModifiable, String::new()),
++                    (UnorderedPsbtError::NotUnordered, String::new()),
 +                    (UnorderedPsbtError::UnorderedSighashSingle, String::new()),
 +                    (UnorderedPsbtError::SortSeedTooShort(len), len.to_string()),
 +                    (UnorderedPsbtError::InputSortKeyTooLong(outpoint), outpoint.to_string()),
 +                    (UnorderedPsbtError::OutputSortKeyTooLong(index), index.to_string()),
++                    (UnorderedPsbtError::UnexpectedSortSeed, String::new()),
++                    (UnorderedPsbtError::UnexpectedInputSortKey(outpoint), outpoint.to_string()),
++                    (UnorderedPsbtError::UnexpectedOutputSortKey(index), index.to_string()),
++                    (UnorderedPsbtError::DuplicateSortKey(value.clone()), format!("{value:02x?}")),
 +                ];
 +                let messages: Vec<_> = errors.iter().map(|(error, _)| error.to_string()).collect();
 +                for ((_, payload), message) in errors.iter().zip(&messages) {
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
              #[test]
              fn is_ok_try_unwrap_consistent(r in arb_result_unordered_psbt()) {
                  if r.is_ok() {
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+                     global: Global {
+                         input_count,
+                         output_count,
+-                        ..Global::default()
++                        ..unordered_global()
+                     },
+                     inputs: vec![],
+                     outputs: vec![],
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+                 let psbt = Psbt {
+                     global: Global {
+                         input_count: outpoints.len(),
+-                        ..Global::default()
++                        ..unordered_global()
+                     },
+                     inputs: outpoints.iter().map(psbt_v2::v2::Input::new).collect(),
+                     outputs: vec![],
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+                 let psbt = Psbt {
+                     global: Global {
+                         output_count: outputs.len(),
+-                        ..Global::default()
++                        ..unordered_global()
+                     },
+                     inputs: vec![],
+                     outputs,

@github-code-quality

github-code-quality Bot commented Nov 14, 2026 •

Copy link
Copy Markdown

Code coverage overview

Languages: Rust

Rust / code-coverage/cargo-llvm-cov

concurrent-psbt-fiel... 5f4ab3b enforce-concurrent-p... 86be9b9 +/-
100% 100% 0%
View coverage of the 10 most impacted files.
File concurrent-psbt-fiel... 5f4ab3b enforce-concurrent-p... 86be9b9 +/-
crates/concurre.../src/psbt/tx.rs 0% 100% +100%
crates/concurre...bt/keyed_set.rs 0% 100% +100%
crates/concurre.../psbt/global.rs 0% 100% +100%
crates/concurre...bt/input_set.rs 0% 100% +100%
crates/concurre...t/output_set.rs 0% 100% +100%
crates/concurre...c/psbt/input.rs 0% 100% +100%
crates/concurre...bt/conflicts.rs 0% 100% +100%
crates/concurre...lattice/lift.rs 0% 100% +100%
crates/concurre.../proprietary.rs 0% 100% +100%
crates/concurre...ce/conflicts.rs 0% 100% +100%

ℹ️ Calculations represent line coverage. Results may change as calculations are updated.


Updated November 16, 2026 23:44 UTC

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from 568bc71 to 4bf7243 Compare November 14, 2026 05:56
@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from 4bf7243 to eb00e80 Compare November 14, 2026 07:01
@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch 2 times, most recently from 49b7b30 to bd05b74 Compare November 14, 2026 08:10
@github-actions

Copy link
Copy Markdown
range-diff for force push 49b7b304df → bd05b74787 November 14, 2026 09:07 UTC: 1 modified; 1 commit; base ae99e06508 → 1227d3a5e5 (diverged, 8 ahead and 8 behind)

reproduce: git range-diff ae99e06..49b7b30 1227d3a..bd05b74

1:  49b7b304df +362 -20 1f ! 1:  bd05b74787 +324 -64 2f reject malformed unordered PSBTs
1: 49b7b304df ! 1: bd05b74787 reject malformed unordered PSBTs
@@ Commit message
     otherwise be lost, and an unordered PSBT must not have the SIGHASH_SINGLE
     bit set.
 
+ ## crates/concurrent-psbt/proptest-regressions/psbt/tx.txt (new) ##
+@@
++# Seeds for failure cases proptest has generated in the past. It is
++# automatically read and these particular cases re-run before any
++# novel cases are generated.
++#
++# It is recommended to check this file in to source control so that
++# everyone who runs the test benefits from these saved cases.
++cc d39ffeae915558d1179aff2afb90b65fc845e008dbbb2dd0dc24d7a65023d779 # shrinks to unordered = None, derivation = Some([])
++cc bd945f0c444bba85866627d0b662f363d4830b01b2577cca95ef68a4e37bf632 # shrinks to seed_len = Some(0), input_key_len = None, output_key_len = None
+
  ## crates/concurrent-psbt/src/psbt/tx.rs ##
 @@ crates/concurrent-psbt/src/psbt/tx.rs: use psbt_v2::v2::Psbt;
  
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                  prop_assert_eq!(joined.is_ok(), inputs_agree && outputs_agree);
              }
  
+-            #[test]
+-            fn error_display_is_distinct_and_names_the_offending_value(
+-                index in any::<usize>(),
+-                len in any::<usize>(),
+-                value in proptest::collection::vec(any::<u8>(), 0..4),
+-                vout in any::<u32>(),
+-            ) {
+-                let outpoint = OutPoint { vout, ..OutPoint::null() };
+-                let errors = [
+-                    (
+-                        UnorderedPsbtError::InputCountMismatch { declared: len, found: index },
+-                        format!("{len} inputs but has {index}"),
+-                    ),
+-                    (
+-                        UnorderedPsbtError::OutputCountMismatch { declared: len, found: index },
+-                        format!("{len} outputs but has {index}"),
+-                    ),
+-                    (UnorderedPsbtError::MissingOutputUniqueId(index), index.to_string()),
+-                    (UnorderedPsbtError::InvalidOutputUniqueId(index), index.to_string()),
+-                    (UnorderedPsbtError::DuplicateInput(outpoint), outpoint.to_string()),
+-                    (
+-                        UnorderedPsbtError::DuplicateOutputUniqueId(UniqueId::new(value.clone())),
+-                        String::new(),
+-                    ),
+-                    (
+-                        UnorderedPsbtError::InvalidUnorderedFlag(value.clone()),
+-                        format!("{value:02x?}"),
+-                    ),
+-                    (
+-                        UnorderedPsbtError::InvalidSortKeyDerivation(value.clone()),
+-                        format!("{value:02x?}"),
+-                    ),
+-                    (UnorderedPsbtError::SortSeedTooShort(len), len.to_string()),
+-                    (UnorderedPsbtError::InputSortKeyTooLong(outpoint), outpoint.to_string()),
+-                    (UnorderedPsbtError::OutputSortKeyTooLong(index), index.to_string()),
+-                ];
+-                let messages: Vec<_> = errors.iter().map(|(error, _)| error.to_string()).collect();
+-                for ((_, payload), message) in errors.iter().zip(&messages) {
+-                    prop_assert!(message.contains(payload.as_str()), "{message:?} lacks {payload:?}");
+-                }
+-                let distinct: std::collections::HashSet<_> = messages.iter().collect();
+-                prop_assert_eq!(distinct.len(), messages.len());
+-            }
+-
+             #[test]
+             fn try_from_psbt_rejects_the_first_invalid_unique_id(
+                 uid_lens in proptest::collection::vec(proptest::option::of(0usize..=34), 0..=4),
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+                 prop_assert_eq!(UnorderedPsbt::try_from_psbt(psbt).map(|u| u.outputs.len()), expected);
+             }
+ 
 +            #[test]
 +            fn try_from_psbt_requires_unordered_without_sighash_single(
 +                flags in 0u8..8,
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                prop_assert_eq!(ResultUnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
 +            }
 +
-+            #[test]
-+            fn try_from_psbt_bounds_sort_field_sizes(
-+                seed_len in proptest::option::of(0usize..=24),
-+                input_key_len in proptest::option::of(0usize..=40),
-+                output_key_len in proptest::option::of(0usize..=40),
-+            ) {
-+                let field = |subtype| psbt_v2::raw::ProprietaryKey {
-+                    prefix: crate::PROPRIETARY_PREFIX.to_vec(),
-+                    subtype,
-+                    key: vec![],
-+                };
-+                let mut global = unordered_global();
-+                let mut input = psbt_v2::v2::Input::new(&OutPoint::null());
-+                let mut output = v2_output_with_uid(vec![1]);
-+                if let Some(len) = seed_len {
-+                    global.proprietaries.insert(
-+                        field(crate::global::PSBT_GLOBAL_SORT_SEED_SUBTYPE),
-+                        vec![0; len],
-+                    );
-+                }
-+                if let Some(len) = input_key_len {
-+                    input
-+                        .proprietaries
-+                        .insert(field(crate::input::PSBT_IN_SORT_KEY_SUBTYPE), vec![0; len]);
-+                }
-+                if let Some(len) = output_key_len {
-+                    output
-+                        .proprietaries
-+                        .insert(field(crate::output::PSBT_OUT_SORT_KEY_SUBTYPE), vec![0; len]);
-+                }
-+                let psbt = v2_psbt_with(global, vec![input], vec![output]);
-+                let long = |len: Option<usize>| len.is_some_and(|len| len > SortKey::MAX_LEN);
-+                let expected = match seed_len {
-+                    Some(len) if len < SortSeed::MIN_LEN => {
-+                        Err(UnorderedPsbtError::SortSeedTooShort(len))
-+                    }
-+                    _ if long(input_key_len) => {
-+                        Err(UnorderedPsbtError::InputSortKeyTooLong(OutPoint::null()))
-+                    }
-+                    _ if long(output_key_len) => Err(UnorderedPsbtError::OutputSortKeyTooLong(0)),
-+                    _ => Ok(()),
-+                };
-+                prop_assert_eq!(ResultUnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
-+            }
-+
+             #[test]
+             fn try_from_psbt_bounds_sort_field_sizes(
+                 seed_len in proptest::option::of(0usize..=24),
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+                 prop_assert_eq!(ResultUnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
+             }
+ 
 +            #[test]
 +            fn try_from_psbt_validates_flag_values(
 +                unordered in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
 +                derivation in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
 +            ) {
-+                let mut global = Global::default();
++                let mut psbt = v2_psbt_with(Global::default(), vec![], vec![]);
 +                for (subtype, value) in [
 +                    (crate::global::PSBT_GLOBAL_TX_UNORDERED_SUBTYPE, &unordered),
 +                    (crate::global::PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE, &derivation),
 +                ] {
 +                    if let Some(value) = value {
-+                        global.proprietaries.insert(
++                        psbt.global.proprietaries.insert(
 +                            psbt_v2::raw::ProprietaryKey {
 +                                prefix: crate::PROPRIETARY_PREFIX.to_vec(),
 +                                subtype,
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                        );
 +                    }
 +                }
-+                let psbt = v2_psbt_with(global, vec![], vec![]);
 +                let expected = match (unordered, derivation) {
 +                    (Some(value), _) if value != [0x03] => {
 +                        Err(UnorderedPsbtError::InvalidUnorderedFlag(value))

@github-actions

Copy link
Copy Markdown
range-diff for force push 49b7b304df → bd05b74787 November 14, 2026 09:08 UTC: 1 modified; 1 commit; base ae99e06508 → 1227d3a5e5 (diverged, 8 ahead and 8 behind)

reproduce: git range-diff ae99e06..49b7b30 1227d3a..bd05b74

1:  49b7b304df +362 -20 1f ! 1:  bd05b74787 +324 -64 2f reject malformed unordered PSBTs
1: 49b7b304df ! 1: bd05b74787 reject malformed unordered PSBTs
@@ Commit message
     otherwise be lost, and an unordered PSBT must not have the SIGHASH_SINGLE
     bit set.
 
+ ## crates/concurrent-psbt/proptest-regressions/psbt/tx.txt (new) ##
+@@
++# Seeds for failure cases proptest has generated in the past. It is
++# automatically read and these particular cases re-run before any
++# novel cases are generated.
++#
++# It is recommended to check this file in to source control so that
++# everyone who runs the test benefits from these saved cases.
++cc d39ffeae915558d1179aff2afb90b65fc845e008dbbb2dd0dc24d7a65023d779 # shrinks to unordered = None, derivation = Some([])
++cc bd945f0c444bba85866627d0b662f363d4830b01b2577cca95ef68a4e37bf632 # shrinks to seed_len = Some(0), input_key_len = None, output_key_len = None
+
  ## crates/concurrent-psbt/src/psbt/tx.rs ##
 @@ crates/concurrent-psbt/src/psbt/tx.rs: use psbt_v2::v2::Psbt;
  
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                  prop_assert_eq!(joined.is_ok(), inputs_agree && outputs_agree);
              }
  
+-            #[test]
+-            fn error_display_is_distinct_and_names_the_offending_value(
+-                index in any::<usize>(),
+-                len in any::<usize>(),
+-                value in proptest::collection::vec(any::<u8>(), 0..4),
+-                vout in any::<u32>(),
+-            ) {
+-                let outpoint = OutPoint { vout, ..OutPoint::null() };
+-                let errors = [
+-                    (
+-                        UnorderedPsbtError::InputCountMismatch { declared: len, found: index },
+-                        format!("{len} inputs but has {index}"),
+-                    ),
+-                    (
+-                        UnorderedPsbtError::OutputCountMismatch { declared: len, found: index },
+-                        format!("{len} outputs but has {index}"),
+-                    ),
+-                    (UnorderedPsbtError::MissingOutputUniqueId(index), index.to_string()),
+-                    (UnorderedPsbtError::InvalidOutputUniqueId(index), index.to_string()),
+-                    (UnorderedPsbtError::DuplicateInput(outpoint), outpoint.to_string()),
+-                    (
+-                        UnorderedPsbtError::DuplicateOutputUniqueId(UniqueId::new(value.clone())),
+-                        String::new(),
+-                    ),
+-                    (
+-                        UnorderedPsbtError::InvalidUnorderedFlag(value.clone()),
+-                        format!("{value:02x?}"),
+-                    ),
+-                    (
+-                        UnorderedPsbtError::InvalidSortKeyDerivation(value.clone()),
+-                        format!("{value:02x?}"),
+-                    ),
+-                    (UnorderedPsbtError::SortSeedTooShort(len), len.to_string()),
+-                    (UnorderedPsbtError::InputSortKeyTooLong(outpoint), outpoint.to_string()),
+-                    (UnorderedPsbtError::OutputSortKeyTooLong(index), index.to_string()),
+-                ];
+-                let messages: Vec<_> = errors.iter().map(|(error, _)| error.to_string()).collect();
+-                for ((_, payload), message) in errors.iter().zip(&messages) {
+-                    prop_assert!(message.contains(payload.as_str()), "{message:?} lacks {payload:?}");
+-                }
+-                let distinct: std::collections::HashSet<_> = messages.iter().collect();
+-                prop_assert_eq!(distinct.len(), messages.len());
+-            }
+-
+             #[test]
+             fn try_from_psbt_rejects_the_first_invalid_unique_id(
+                 uid_lens in proptest::collection::vec(proptest::option::of(0usize..=34), 0..=4),
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+                 prop_assert_eq!(UnorderedPsbt::try_from_psbt(psbt).map(|u| u.outputs.len()), expected);
+             }
+ 
 +            #[test]
 +            fn try_from_psbt_requires_unordered_without_sighash_single(
 +                flags in 0u8..8,
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                prop_assert_eq!(ResultUnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
 +            }
 +
-+            #[test]
-+            fn try_from_psbt_bounds_sort_field_sizes(
-+                seed_len in proptest::option::of(0usize..=24),
-+                input_key_len in proptest::option::of(0usize..=40),
-+                output_key_len in proptest::option::of(0usize..=40),
-+            ) {
-+                let field = |subtype| psbt_v2::raw::ProprietaryKey {
-+                    prefix: crate::PROPRIETARY_PREFIX.to_vec(),
-+                    subtype,
-+                    key: vec![],
-+                };
-+                let mut global = unordered_global();
-+                let mut input = psbt_v2::v2::Input::new(&OutPoint::null());
-+                let mut output = v2_output_with_uid(vec![1]);
-+                if let Some(len) = seed_len {
-+                    global.proprietaries.insert(
-+                        field(crate::global::PSBT_GLOBAL_SORT_SEED_SUBTYPE),
-+                        vec![0; len],
-+                    );
-+                }
-+                if let Some(len) = input_key_len {
-+                    input
-+                        .proprietaries
-+                        .insert(field(crate::input::PSBT_IN_SORT_KEY_SUBTYPE), vec![0; len]);
-+                }
-+                if let Some(len) = output_key_len {
-+                    output
-+                        .proprietaries
-+                        .insert(field(crate::output::PSBT_OUT_SORT_KEY_SUBTYPE), vec![0; len]);
-+                }
-+                let psbt = v2_psbt_with(global, vec![input], vec![output]);
-+                let long = |len: Option<usize>| len.is_some_and(|len| len > SortKey::MAX_LEN);
-+                let expected = match seed_len {
-+                    Some(len) if len < SortSeed::MIN_LEN => {
-+                        Err(UnorderedPsbtError::SortSeedTooShort(len))
-+                    }
-+                    _ if long(input_key_len) => {
-+                        Err(UnorderedPsbtError::InputSortKeyTooLong(OutPoint::null()))
-+                    }
-+                    _ if long(output_key_len) => Err(UnorderedPsbtError::OutputSortKeyTooLong(0)),
-+                    _ => Ok(()),
-+                };
-+                prop_assert_eq!(ResultUnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
-+            }
-+
+             #[test]
+             fn try_from_psbt_bounds_sort_field_sizes(
+                 seed_len in proptest::option::of(0usize..=24),
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+                 prop_assert_eq!(ResultUnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
+             }
+ 
 +            #[test]
 +            fn try_from_psbt_validates_flag_values(
 +                unordered in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
 +                derivation in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
 +            ) {
-+                let mut global = Global::default();
++                let mut psbt = v2_psbt_with(Global::default(), vec![], vec![]);
 +                for (subtype, value) in [
 +                    (crate::global::PSBT_GLOBAL_TX_UNORDERED_SUBTYPE, &unordered),
 +                    (crate::global::PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE, &derivation),
 +                ] {
 +                    if let Some(value) = value {
-+                        global.proprietaries.insert(
++                        psbt.global.proprietaries.insert(
 +                            psbt_v2::raw::ProprietaryKey {
 +                                prefix: crate::PROPRIETARY_PREFIX.to_vec(),
 +                                subtype,
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                        );
 +                    }
 +                }
-+                let psbt = v2_psbt_with(global, vec![], vec![]);
 +                let expected = match (unordered, derivation) {
 +                    (Some(value), _) if value != [0x03] => {
 +                        Err(UnorderedPsbtError::InvalidUnorderedFlag(value))

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from bd05b74 to a9581c5 Compare November 14, 2026 10:58
@github-actions

Copy link
Copy Markdown
range-diff for force push bd05b74787 → a9581c5710 November 14, 2026 10:58 UTC: 1 modified; 1 commit; base 1227d3a5e5 → 08c8dd432a (diverged, 10 ahead and 9 behind)

reproduce: git range-diff 1227d3a..bd05b74 08c8dd4..a9581c5

1:  bd05b74787 +324 -64 2f ! 1:  a9581c5710 +340 -18 2f reject malformed unordered PSBTs
1: bd05b74787 ! 1: a9581c5710 reject malformed unordered PSBTs
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl std::error::Error for UnorderedPsbtE
  impl UnorderedPsbt {
      /// Parse a v2 PSBT into unordered representation.
 @@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
-     /// Joining by outpoint and unique ID is for merging copies of a PSBT, not
-     /// for entries within one.
+     /// joining the duplicates would hide the problem unless their fields
+     /// conflicted.
      ///
 +    /// The PSBT must be marked unordered, since reading an ordered PSBT as
 +    /// unordered would discard its order.
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
      /// Returns a count mismatch if the declared input or output count is not
      /// the number of inputs or outputs, which only a `Psbt` assembled by hand
      /// can have. Otherwise returns a malformed global sort field, then the
-     /// first input with a sort key longer than [`SortKey::MAX_LEN`] bytes,
--    /// then the first input whose outpoint repeats, then the first output that
--    /// is missing a `PSBT_OUT_UNIQUE_ID` field, has one longer than
--    /// [`UniqueId::MAX_LEN`] bytes or a sort key longer than
--    /// [`SortKey::MAX_LEN`] bytes, or repeats a unique ID.
-+    /// then the first output that is missing a `PSBT_OUT_UNIQUE_ID` field, has
-+    /// one longer than [`UniqueId::MAX_LEN`] bytes or a sort key longer than
-+    /// [`SortKey::MAX_LEN`] bytes.
+     /// first input whose sort key is longer than [`SortKey::MAX_LEN`] bytes,
+-    /// then the first input whose outpoint repeats, then the first output
+-    /// whose `PSBT_OUT_UNIQUE_ID` is missing, empty or longer than
+-    /// [`UniqueId::MAX_LEN`] bytes, or whose sort key is longer than
+-    /// [`SortKey::MAX_LEN`] bytes, then the first unique ID that repeats.
++    /// then the first output whose `PSBT_OUT_UNIQUE_ID` is missing, empty or
++    /// longer than [`UniqueId::MAX_LEN`] bytes, or whose sort key is longer
++    /// than [`SortKey::MAX_LEN`] bytes.
 +    ///
-+    /// Then returns [`UnorderedPsbtError::NotUnordered`] for an ordered PSBT
-+    /// and [`UnorderedPsbtError::UnorderedSighashSingle`] for the
-+    /// `SIGHASH_SINGLE` flag. Then returns
-+    /// [`UnorderedPsbtError::UnexpectedSortSeed`],
++    /// Then returns [`UnorderedPsbtError::NotUnordered`] for an ordered PSBT,
++    /// [`UnorderedPsbtError::UnorderedSighashSingle`] if the `SIGHASH_SINGLE`
++    /// flag is set, [`UnorderedPsbtError::UnexpectedSortSeed`],
 +    /// [`UnorderedPsbtError::UnexpectedInputSortKey`] or
 +    /// [`UnorderedPsbtError::UnexpectedOutputSortKey`] for a sort field that
 +    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` rules out, and
-+    /// [`UnorderedPsbtError::DuplicateSortKey`] for the first repeated sort
-+    /// key. Then returns the first input whose outpoint repeats, then the
-+    /// first output whose unique ID repeats.
++    /// [`UnorderedPsbtError::DuplicateSortKey`] for the first sort key that
++    /// repeats among the inputs, then among the outputs. Finally returns the
++    /// first input whose outpoint repeats, then the first unique ID that
++    /// repeats.
      pub fn try_from_psbt(psbt: Psbt) -> Result<Self, UnorderedPsbtError> {
          let Psbt {
              global,
-@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
-             });
-         }
- 
--        // A set that is not modifiable is frozen, so it joins only with an
--        // identical set.
-         let global = Global::try_from(global)?;
-         let inputs = inputs
-             .into_iter()
 @@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
                      .map_err(|_| UnorderedPsbtError::InputSortKeyTooLong(outpoint))
              })
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
              .collect::<Result<Vec<_>, _>>()?;
 +        validate_unordered(&global, &inputs, &outputs)?;
 +
-+        // A set that is not modifiable is frozen, so it joins only with an
-+        // identical set.
 +        let inputs = InputSet::try_from_inputs(inputs)?;
 +        let inputs = if global.tx_modifiable_flags & INPUTS_MODIFIABLE == 0 {
 +            inputs.freeze()
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
      mod unit {
          use super::*;
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
- 
-         fn make_unordered_psbt() -> UnorderedPsbt {
              UnorderedPsbt {
--                global: Global::default(),
-+                global: unordered_global(),
-                 inputs: InputSet::default(),
-                 outputs: OutputSet::default(),
-             }
+                 global: Global {
+                     tx_modifiable_flags: INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE,
+-                    ..Global::default()
++                    ..unordered_global()
+                 },
+                 inputs: InputSet::try_from_inputs([input]).unwrap(),
+                 outputs: OutputSet::try_from_outputs([output]).unwrap(),
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
-             );
- 
-             for (error, message) in [
+                     UnorderedPsbtError::OutputSortKeyTooLong(1),
+                     "sort key of output 1 is longer than 32 bytes".to_string(),
+                 ),
 +                (
 +                    UnorderedPsbtError::NotUnordered,
-+                    "PSBT is not marked unordered".to_owned(),
++                    "PSBT is not marked unordered".to_string(),
 +                ),
 +                (
 +                    UnorderedPsbtError::UnorderedSighashSingle,
-+                    "unordered PSBT has the SIGHASH_SINGLE flag set".to_owned(),
++                    "unordered PSBT has the SIGHASH_SINGLE flag set".to_string(),
 +                ),
-                 (
-                     UnorderedPsbtError::InvalidUnorderedFlag(vec![1]),
-                     "PSBT_GLOBAL_TX_UNORDERED is [01], not 0x03".to_owned(),
++                (
++                    UnorderedPsbtError::UnexpectedSortSeed,
++                    "PSBT_GLOBAL_SORT_SEED is set but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x00"
++                        .to_string(),
++                ),
++                (
++                    UnorderedPsbtError::UnexpectedInputSortKey(outpoint(1)),
++                    format!(
++                        "the input spending {} has a sort key but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x01",
++                        outpoint(1)
++                    ),
++                ),
++                (
++                    UnorderedPsbtError::UnexpectedOutputSortKey(1),
++                    "output 1 has a sort key but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x01"
++                        .to_string(),
++                ),
++                (
++                    UnorderedPsbtError::DuplicateSortKey(vec![0xab]),
++                    "duplicate sort key [ab]".to_string(),
++                ),
+             ];
+             for (error, message) in cases {
+                 assert_eq!(error.to_string(), message);
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
-             UnorderedPsbt {
-                 global: Global {
-                     tx_modifiable_flags: INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE,
--                    ..Global::default()
-+                    ..unordered_global()
-                 },
-                 inputs,
-                 outputs,
+             }
+         }
+ 
++        #[test]
++        fn psbts_that_break_the_sort_rules_are_rejected() {
++            use SortKeyDerivation::{Derived, Explicit};
++
++            let global = |derivation: Option<SortKeyDerivation>, seeded: bool| {
++                let mut global = unordered_global();
++                if let Some(derivation) = derivation {
++                    global.set_sort_key_derivation(derivation);
++                }
++                if seeded {
++                    global.set_sort_seed(SortSeed::try_from(vec![0; 16]).unwrap());
++                }
++                global
++            };
++            let input = |txid_byte, sort_key: Option<u8>| {
++                let mut input = Input::new(&outpoint(txid_byte));
++                if let Some(key) = sort_key {
++                    input.set_sort_key(SortKey::try_from(vec![key]).unwrap());
++                }
++                psbt_v2::v2::Input::from(input)
++            };
++            let output = |uid, sort_key: Option<u8>| {
++                let mut output =
++                    Output::new(UniqueId::new(vec![uid]), Amount::ZERO, ScriptBuf::new());
++                if let Some(key) = sort_key {
++                    output.set_sort_key(SortKey::try_from(vec![key]).unwrap());
++                }
++                psbt_v2::v2::Output::from(output)
++            };
++            let sighash_single = Global {
++                tx_modifiable_flags: HAS_SIGHASH_SINGLE,
++                ..unordered_global()
++            };
++            let cases = [
++                (
++                    v2_psbt_with(Global::default(), vec![], vec![]),
++                    Err(UnorderedPsbtError::NotUnordered),
++                ),
++                (
++                    v2_psbt_with(sighash_single, vec![], vec![]),
++                    Err(UnorderedPsbtError::UnorderedSighashSingle),
++                ),
++                (
++                    v2_psbt_with(global(Some(Explicit), true), vec![], vec![]),
++                    Err(UnorderedPsbtError::UnexpectedSortSeed),
++                ),
++                (
++                    v2_psbt_with(
++                        global(Some(Derived), true),
++                        vec![input(1, None), input(2, Some(0))],
++                        vec![],
++                    ),
++                    Err(UnorderedPsbtError::UnexpectedInputSortKey(outpoint(2))),
++                ),
++                (
++                    v2_psbt_with(
++                        global(Some(Derived), true),
++                        vec![],
++                        vec![output(1, None), output(2, Some(0))],
++                    ),
++                    Err(UnorderedPsbtError::UnexpectedOutputSortKey(1)),
++                ),
++                (
++                    v2_psbt_with(
++                        global(Some(Explicit), false),
++                        vec![input(1, Some(0)), input(2, Some(0))],
++                        vec![],
++                    ),
++                    Err(UnorderedPsbtError::DuplicateSortKey(vec![0])),
++                ),
++                (
++                    v2_psbt_with(
++                        global(Some(Explicit), false),
++                        vec![],
++                        vec![output(1, Some(0)), output(2, Some(0))],
++                    ),
++                    Err(UnorderedPsbtError::DuplicateSortKey(vec![0])),
++                ),
++                // Derived sort keys need a seed and no explicit keys.
++                (
++                    v2_psbt_with(
++                        global(Some(Derived), true),
++                        vec![input(1, None)],
++                        vec![output(1, None)],
++                    ),
++                    Ok(()),
++                ),
++                // An input and an output may share a sort key.
++                (
++                    v2_psbt_with(
++                        global(Some(Explicit), false),
++                        vec![input(1, Some(0))],
++                        vec![output(1, Some(0))],
++                    ),
++                    Ok(()),
++                ),
++            ];
++            for (psbt, expected) in cases {
++                assert_eq!(UnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
++            }
++        }
++
+         #[test]
+         fn serialized_psbts_with_disjoint_entries_join_into_their_union() {
+             let joined = (1..=3)
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                                  transaction::Version::TWO
                              },
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                          inputs,
                          outputs,
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
-                 prop_assert_eq!(joined.is_ok(), inputs_agree && outputs_agree);
-             }
- 
--            #[test]
--            fn error_display_is_distinct_and_names_the_offending_value(
--                index in any::<usize>(),
--                len in any::<usize>(),
--                value in proptest::collection::vec(any::<u8>(), 0..4),
--                vout in any::<u32>(),
--            ) {
--                let outpoint = OutPoint { vout, ..OutPoint::null() };
--                let errors = [
--                    (
--                        UnorderedPsbtError::InputCountMismatch { declared: len, found: index },
--                        format!("{len} inputs but has {index}"),
--                    ),
--                    (
--                        UnorderedPsbtError::OutputCountMismatch { declared: len, found: index },
--                        format!("{len} outputs but has {index}"),
--                    ),
--                    (UnorderedPsbtError::MissingOutputUniqueId(index), index.to_string()),
--                    (UnorderedPsbtError::InvalidOutputUniqueId(index), index.to_string()),
--                    (UnorderedPsbtError::DuplicateInput(outpoint), outpoint.to_string()),
--                    (
--                        UnorderedPsbtError::DuplicateOutputUniqueId(UniqueId::new(value.clone())),
--                        String::new(),
--                    ),
--                    (
--                        UnorderedPsbtError::InvalidUnorderedFlag(value.clone()),
--                        format!("{value:02x?}"),
--                    ),
--                    (
--                        UnorderedPsbtError::InvalidSortKeyDerivation(value.clone()),
--                        format!("{value:02x?}"),
--                    ),
--                    (UnorderedPsbtError::SortSeedTooShort(len), len.to_string()),
--                    (UnorderedPsbtError::InputSortKeyTooLong(outpoint), outpoint.to_string()),
--                    (UnorderedPsbtError::OutputSortKeyTooLong(index), index.to_string()),
--                ];
--                let messages: Vec<_> = errors.iter().map(|(error, _)| error.to_string()).collect();
--                for ((_, payload), message) in errors.iter().zip(&messages) {
--                    prop_assert!(message.contains(payload.as_str()), "{message:?} lacks {payload:?}");
--                }
--                let distinct: std::collections::HashSet<_> = messages.iter().collect();
--                prop_assert_eq!(distinct.len(), messages.len());
--            }
--
-             #[test]
-             fn try_from_psbt_rejects_the_first_invalid_unique_id(
-                 uid_lens in proptest::collection::vec(proptest::option::of(0usize..=34), 0..=4),
+                         Some(format!("{len} outputs but has {index}")),
+                     ),
+                     (UnorderedPsbtError::InvalidUnorderedFlag(value.clone()), Some(bytes.clone())),
+-                    (UnorderedPsbtError::InvalidSortKeyDerivation(value.clone()), Some(bytes)),
++                    (UnorderedPsbtError::InvalidSortKeyDerivation(value.clone()), Some(bytes.clone())),
+                     (UnorderedPsbtError::SortSeedTooShort(len), Some(len.to_string())),
+                     (UnorderedPsbtError::InputSortKeyTooLong(outpoint), Some(outpoint.to_string())),
+                     (UnorderedPsbtError::MissingOutputUniqueId(index), Some(index.to_string())),
+                     (UnorderedPsbtError::InvalidOutputUniqueId(index), Some(index.to_string())),
+                     (UnorderedPsbtError::OutputSortKeyTooLong(index), Some(index.to_string())),
+                     (UnorderedPsbtError::DuplicateInput(outpoint), Some(outpoint.to_string())),
++                    (UnorderedPsbtError::NotUnordered, None),
++                    (UnorderedPsbtError::UnorderedSighashSingle, None),
++                    (UnorderedPsbtError::UnexpectedSortSeed, None),
++                    (UnorderedPsbtError::UnexpectedInputSortKey(outpoint), Some(outpoint.to_string())),
++                    (UnorderedPsbtError::UnexpectedOutputSortKey(index), Some(index.to_string())),
++                    (UnorderedPsbtError::DuplicateSortKey(value.clone()), Some(format!("{value:02x?}"))),
+                     // The unique ID is opaque bytes, so the message leaves it out.
+                     (UnorderedPsbtError::DuplicateOutputUniqueId(UniqueId::new(value)), None),
+                 ];
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                  prop_assert_eq!(UnorderedPsbt::try_from_psbt(psbt).map(|u| u.outputs.len()), expected);
              }
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +            }
 +
 +            #[test]
-+            fn try_from_psbt_checks_sort_fields_against_derivation(
-+                derivation in proptest::option::of(prop_oneof![
-+                    Just(SortKeyDerivation::Explicit),
-+                    Just(SortKeyDerivation::Derived),
-+                ]),
-+                seeded in proptest::bool::ANY,
-+                input_keys in proptest::collection::vec(proptest::option::of(0u8..3), 0..4),
-+                output_keys in proptest::collection::vec(proptest::option::of(0u8..3), 0..4),
++            fn try_from_psbt_rejects_the_first_repeated_sort_key(
++                distinct in proptest::collection::hash_set(any::<u8>(), 1..=3),
++                repeat in any::<proptest::sample::Index>(),
++                tail in proptest::collection::vec(any::<u8>(), 0..=2),
++                on_outputs in proptest::bool::ANY,
 +            ) {
-+                let mut global = unordered_global();
-+                if let Some(derivation) = derivation {
-+                    global.set_sort_key_derivation(derivation);
-+                }
-+                if seeded {
-+                    global.set_sort_seed(SortSeed::try_from(vec![0; 16]).expect("16 bytes"));
-+                }
-+                let outpoint = |vout| OutPoint { vout, ..OutPoint::null() };
-+                let inputs: Vec<_> = (0u32..)
-+                    .zip(&input_keys)
-+                    .map(|(vout, key)| {
-+                        let mut input = Input::new(&outpoint(vout));
-+                        if let Some(key) = key {
-+                            input.set_sort_key(SortKey::try_from(vec![*key]).expect("short"));
-+                        }
-+                        input.into()
-+                    })
-+                    .collect();
-+                let outputs: Vec<_> = (0u8..)
-+                    .zip(&output_keys)
-+                    .map(|(uid, key)| {
-+                        let mut output = Output::new(
-+                            UniqueId::new(vec![uid]),
-+                            bitcoin::Amount::ZERO,
-+                            bitcoin::ScriptBuf::new(),
-+                        );
-+                        if let Some(key) = key {
-+                            output.set_sort_key(SortKey::try_from(vec![*key]).expect("short"));
-+                        }
-+                        output.into()
-+                    })
-+                    .collect();
-+                let psbt = v2_psbt_with(global, inputs, outputs);
-+                let first_repeat = |keys: &[Option<u8>]| {
-+                    let keys: Vec<u8> = keys.iter().flatten().copied().collect();
-+                    keys.iter()
-+                        .enumerate()
-+                        .find(|&(i, key)| keys[..i].contains(key))
-+                        .map(|(_, key)| vec![*key])
-+                };
-+                let input_key = input_keys.iter().position(Option::is_some);
-+                let output_key = output_keys.iter().position(Option::is_some);
-+                let expected = match derivation {
-+                    Some(SortKeyDerivation::Explicit) if seeded => Err(UnorderedPsbtError::UnexpectedSortSeed),
-+                    Some(SortKeyDerivation::Derived) if input_key.is_some() => Err(UnorderedPsbtError::UnexpectedInputSortKey(
-+                        outpoint(u32::try_from(input_key.unwrap()).unwrap()),
-+                    )),
-+                    Some(SortKeyDerivation::Derived) if output_key.is_some() => {
-+                        Err(UnorderedPsbtError::UnexpectedOutputSortKey(output_key.unwrap()))
-+                    }
-+                    _ => match first_repeat(&input_keys).or_else(|| first_repeat(&output_keys)) {
-+                        Some(key) => Err(UnorderedPsbtError::DuplicateSortKey(key)),
-+                        None => Ok(()),
-+                    },
-+                };
-+                prop_assert_eq!(ResultUnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
-+            }
-+
-             #[test]
-             fn try_from_psbt_bounds_sort_field_sizes(
-                 seed_len in proptest::option::of(0usize..=24),
-@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
-                 prop_assert_eq!(ResultUnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
-             }
- 
-+            #[test]
-+            fn try_from_psbt_validates_flag_values(
-+                unordered in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
-+                derivation in proptest::option::of(proptest::collection::vec(0u8..4, 0..3)),
-+            ) {
-+                let mut psbt = v2_psbt_with(Global::default(), vec![], vec![]);
-+                for (subtype, value) in [
-+                    (crate::global::PSBT_GLOBAL_TX_UNORDERED_SUBTYPE, &unordered),
-+                    (crate::global::PSBT_GLOBAL_SORT_KEY_DERIVATION_SUBTYPE, &derivation),
-+                ] {
-+                    if let Some(value) = value {
-+                        psbt.global.proprietaries.insert(
-+                            psbt_v2::raw::ProprietaryKey {
-+                                prefix: crate::PROPRIETARY_PREFIX.to_vec(),
-+                                subtype,
-+                                key: vec![],
-+                            },
-+                            value.clone(),
-+                        );
-+                    }
-+                }
-+                let expected = match (unordered, derivation) {
-+                    (Some(value), _) if value != [0x03] => {
-+                        Err(UnorderedPsbtError::InvalidUnorderedFlag(value))
-+                    }
-+                    (_, Some(value)) if value != [0x00] && value != [0x01] => {
-+                        Err(UnorderedPsbtError::InvalidSortKeyDerivation(value))
-+                    }
-+                    (None, _) => Err(UnorderedPsbtError::NotUnordered),
-+                    _ => Ok(()),
++                let distinct: Vec<u8> = distinct.into_iter().collect();
++                let repeated = distinct[repeat.index(distinct.len())];
++                let keys: Vec<u8> = distinct.iter().copied().chain([repeated]).chain(tail).collect();
++                let sort_key = |key| SortKey::try_from(vec![key]).expect("one byte");
++                let entries = (0u8..).zip(keys);
++                let psbt = if on_outputs {
++                    let outputs = entries
++                        .map(|(uid, key)| {
++                            let mut output = Output::new(
++                                UniqueId::new(vec![uid]),
++                                bitcoin::Amount::ZERO,
++                                bitcoin::ScriptBuf::new(),
++                            );
++                            output.set_sort_key(sort_key(key));
++                            output.into()
++                        })
++                        .collect();
++                    v2_psbt(vec![], outputs)
++                } else {
++                    let inputs = entries
++                        .map(|(vout, key)| {
++                            let mut input = Input::new(&OutPoint { vout: vout.into(), ..OutPoint::null() });
++                            input.set_sort_key(sort_key(key));
++                            input.into()
++                        })
++                        .collect();
++                    v2_psbt(inputs, vec![])
 +                };
-+                prop_assert_eq!(ResultUnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
-+            }
-+
-+            #[test]
-+            fn error_display_is_distinct_and_names_the_offending_value(
-+                index in any::<usize>(),
-+                len in any::<usize>(),
-+                value in proptest::collection::vec(any::<u8>(), 0..4),
-+                vout in any::<u32>(),
-+            ) {
-+                let outpoint = OutPoint { vout, ..OutPoint::null() };
-+                let errors = [
-+                    (
-+                        UnorderedPsbtError::InputCountMismatch { declared: len, found: index },
-+                        format!("{len} inputs but has {index}"),
-+                    ),
-+                    (
-+                        UnorderedPsbtError::OutputCountMismatch { declared: len, found: index },
-+                        format!("{len} outputs but has {index}"),
-+                    ),
-+                    (UnorderedPsbtError::MissingOutputUniqueId(index), index.to_string()),
-+                    (UnorderedPsbtError::InvalidOutputUniqueId(index), index.to_string()),
-+                    (UnorderedPsbtError::DuplicateInput(outpoint), outpoint.to_string()),
-+                    (
-+                        UnorderedPsbtError::DuplicateOutputUniqueId(UniqueId::new(value.clone())),
-+                        String::new(),
-+                    ),
-+                    (
-+                        UnorderedPsbtError::InvalidUnorderedFlag(value.clone()),
-+                        format!("{value:02x?}"),
-+                    ),
-+                    (
-+                        UnorderedPsbtError::InvalidSortKeyDerivation(value.clone()),
-+                        format!("{value:02x?}"),
-+                    ),
-+                    (UnorderedPsbtError::NotUnordered, String::new()),
-+                    (UnorderedPsbtError::UnorderedSighashSingle, String::new()),
-+                    (UnorderedPsbtError::SortSeedTooShort(len), len.to_string()),
-+                    (UnorderedPsbtError::InputSortKeyTooLong(outpoint), outpoint.to_string()),
-+                    (UnorderedPsbtError::OutputSortKeyTooLong(index), index.to_string()),
-+                    (UnorderedPsbtError::UnexpectedSortSeed, String::new()),
-+                    (UnorderedPsbtError::UnexpectedInputSortKey(outpoint), outpoint.to_string()),
-+                    (UnorderedPsbtError::UnexpectedOutputSortKey(index), index.to_string()),
-+                    (UnorderedPsbtError::DuplicateSortKey(value.clone()), format!("{value:02x?}")),
-+                ];
-+                let messages: Vec<_> = errors.iter().map(|(error, _)| error.to_string()).collect();
-+                for ((_, payload), message) in errors.iter().zip(&messages) {
-+                    prop_assert!(message.contains(payload.as_str()), "{message:?} lacks {payload:?}");
-+                }
-+                let distinct: std::collections::HashSet<_> = messages.iter().collect();
-+                prop_assert_eq!(distinct.len(), messages.len());
++                prop_assert_eq!(
++                    UnorderedPsbt::try_from_psbt(psbt).map(|_| ()),
++                    Err(UnorderedPsbtError::DuplicateSortKey(vec![repeated]))
++                );
 +            }
 +
              #[test]
-             fn is_ok_try_unwrap_consistent(r in arb_result_unordered_psbt()) {
-                 if r.is_ok() {
+             fn is_ok_iff_try_unwrap_succeeds(r in arb_result_unordered_psbt()) {
+                 prop_assert_eq!(r.is_ok(), r.try_unwrap().is_ok());

Comment thread crates/concurrent-psbt/src/psbt/tx.rs Outdated
}
_ => {}
}
duplicate_sort_key(inputs.iter().filter_map(|input| input.sort_key()))

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Parse checks don't hold for values built in code

The checks added here run only in try_from_psbt, so an UnorderedPsbt built in code can hold a state that into_psbt serializes and try_from_psbt then rejects: joining two PSBTs whose distinct inputs share a sort key (DuplicateSortKey, and the join is_ok()), a global left at Global::default() (NotUnordered), or set_sort_key_derivation(Explicit) with a seed set (UnexpectedSortSeed). @yuval-block, is validating only at parse intended, or should the type (and join) enforce these?

oak · automated · a9581c5

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from a9581c5 to 6a0b965 Compare November 14, 2026 12:21
@github-actions

Copy link
Copy Markdown
range-diff for force push a9581c5710 → 6a0b965918 November 14, 2026 12:21 UTC: 1 modified; 1 commit; base 08c8dd432a → 1d68eb5c8c (diverged, 8 ahead and 8 behind)

reproduce: git range-diff 08c8dd4..a9581c5 1d68eb5..6a0b965

1:  a9581c5710 +340 -18 2f ! 1:  6a0b965918 +340 -18 2f reject malformed unordered PSBTs
1: a9581c5710 ! 1: 6a0b965918 reject malformed unordered PSBTs
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                    ),
 +                    Err(UnorderedPsbtError::DuplicateSortKey(vec![0])),
 +                ),
-+                // Derived sort keys need a seed and no explicit keys.
++                // Seeded derivation accepts entries without explicit keys.
 +                (
 +                    v2_psbt_with(
 +                        global(Some(Derived), true),

@github-actions

Copy link
Copy Markdown
range-diff for force push a9581c5710 → 6a0b965918 November 14, 2026 12:21 UTC: 1 modified; 1 commit; base 08c8dd432a → 1d68eb5c8c (diverged, 8 ahead and 8 behind)

reproduce: git range-diff 08c8dd4..a9581c5 1d68eb5..6a0b965

1:  a9581c5710 +340 -18 2f ! 1:  6a0b965918 +340 -18 2f reject malformed unordered PSBTs
1: a9581c5710 ! 1: 6a0b965918 reject malformed unordered PSBTs
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                    ),
 +                    Err(UnorderedPsbtError::DuplicateSortKey(vec![0])),
 +                ),
-+                // Derived sort keys need a seed and no explicit keys.
++                // Seeded derivation accepts entries without explicit keys.
 +                (
 +                    v2_psbt_with(
 +                        global(Some(Derived), true),

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from 6a0b965 to a271a32 Compare November 14, 2026 13:22
@github-actions

Copy link
Copy Markdown
range-diff for force push 6a0b965918 → a271a321e1 November 14, 2026 13:36 UTC: 1 unchanged; 1 commit; base 1d68eb5c8c → 62667029b5 (diverged, 9 ahead and 9 behind)

reproduce: git range-diff 1d68eb5..6a0b965 6266702..a271a32

1:  6a0b965918 +340 -18 2f = 1:  a271a321e1 +340 -18 2f reject malformed unordered PSBTs

@github-actions

Copy link
Copy Markdown
range-diff for force push 6a0b965918 → a271a321e1 November 14, 2026 13:37 UTC: 1 unchanged; 1 commit; base 1d68eb5c8c → 62667029b5 (diverged, 9 ahead and 9 behind)

reproduce: git range-diff 1d68eb5..6a0b965 6266702..a271a32

1:  6a0b965918 +340 -18 2f = 1:  a271a321e1 +340 -18 2f reject malformed unordered PSBTs

@github-actions

Copy link
Copy Markdown
range-diff for force push 14bdc5dc6e → 4b960b27d1 November 14, 2026 22:38 UTC: 1 unchanged; 1 commit; base d7bcb09b32 → 65c25793a5 (diverged, 10 ahead and 9 behind)

reproduce: git range-diff d7bcb09..14bdc5d 65c2579..4b960b2

1:  14bdc5dc6e +340 -18 2f = 1:  4b960b27d1 +340 -18 2f reject malformed unordered PSBTs

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from 4b960b2 to 52c5c10 Compare November 14, 2026 23:49
@github-actions

Copy link
Copy Markdown
range-diff for force push 4b960b27d1 → 52c5c10828 November 14, 2026 23:49 UTC: 1 modified; 1 commit; base 65c25793a5 → 80ea45da32 (diverged, 7 ahead and 6 behind)

reproduce: git range-diff 65c2579..4b960b2 80ea45d..52c5c10

1:  4b960b27d1 +340 -18 2f ! 1:  52c5c10828 +336 -18 2f reject malformed unordered PSBTs
1: 4b960b27d1 ! 1: 52c5c10828 reject malformed unordered PSBTs
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl std::error::Error for UnorderedPsbtE
 +    if !global.is_unordered() {
 +        return Err(UnorderedPsbtError::NotUnordered);
 +    }
-+    if global.tx_modifiable_flags & HAS_SIGHASH_SINGLE != 0 {
++    if global.tx_modifiable_flags() & HAS_SIGHASH_SINGLE != 0 {
 +        return Err(UnorderedPsbtError::UnorderedSighashSingle);
 +    }
 +    match global.sort_key_derivation() {
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
              })
              .collect::<Result<Vec<_>, _>>()?;
 -        let inputs = InputSet::try_from_inputs(inputs)?;
--        let inputs = if global.tx_modifiable_flags & INPUTS_MODIFIABLE == 0 {
+-        let inputs = if global.tx_modifiable_flags() & INPUTS_MODIFIABLE == 0 {
 -            inputs.freeze()
 -        } else {
 -            inputs
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 +        validate_unordered(&global, &inputs, &outputs)?;
 +
 +        let inputs = InputSet::try_from_inputs(inputs)?;
-+        let inputs = if global.tx_modifiable_flags & INPUTS_MODIFIABLE == 0 {
++        let inputs = if global.tx_modifiable_flags() & INPUTS_MODIFIABLE == 0 {
 +            inputs.freeze()
 +        } else {
 +            inputs
 +        };
          let outputs = OutputSet::try_from_outputs(outputs)?;
-         let outputs = if global.tx_modifiable_flags & OUTPUTS_MODIFIABLE == 0 {
+         let outputs = if global.tx_modifiable_flags() & OUTPUTS_MODIFIABLE == 0 {
              outputs.freeze()
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
          output
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
      mod unit {
          use super::*;
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+                 Amount::from_sat(100_000),
+                 ScriptBuf::new_op_return([byte; 20]),
+             );
+-            let mut global = Global::default();
++            let mut global = unordered_global();
+             global.set_tx_modifiable_flags(INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE);
              UnorderedPsbt {
-                 global: Global {
-                     tx_modifiable_flags: INPUTS_MODIFIABLE | OUTPUTS_MODIFIABLE,
--                    ..Global::default()
-+                    ..unordered_global()
-                 },
-                 inputs: InputSet::try_from_inputs([input]).unwrap(),
-                 outputs: OutputSet::try_from_outputs([output]).unwrap(),
+                 global,
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                      UnorderedPsbtError::OutputSortKeyTooLong(1),
                      "sort key of output 1 is longer than 32 bytes".to_string(),
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                }
 +                psbt_v2::v2::Output::from(output)
 +            };
-+            let sighash_single = Global {
-+                tx_modifiable_flags: HAS_SIGHASH_SINGLE,
-+                ..unordered_global()
-+            };
++            let mut sighash_single = unordered_global();
++            sighash_single.set_tx_modifiable_flags(HAS_SIGHASH_SINGLE);
 +            let cases = [
 +                (
 +                    v2_psbt_with(Global::default(), vec![], vec![]),
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
          fn serialized_psbts_with_disjoint_entries_join_into_their_union() {
              let joined = (1..=3)
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
-                                 transaction::Version::TWO
-                             },
-                             tx_modifiable_flags: flags,
--                            ..Global::default()
-+                            ..unordered_global()
-                         },
-                         inputs,
-                         outputs,
+                         }))
+                         .expect("distinct UIDs");
+ 
+-                    let mut global = Global::default();
++                    let mut global = unordered_global();
+                     global.set_tx_version(if use_v1 {
+                         transaction::Version::ONE
+                     } else {
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                          Some(format!("{len} outputs but has {index}")),
                      ),
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                flags in 0u8..8,
 +                unordered in proptest::bool::ANY,
 +            ) {
-+                let mut global = Global {
-+                    tx_modifiable_flags: flags,
-+                    ..Global::default()
-+                };
++                let mut global = Global::default();
++                global.set_tx_modifiable_flags(flags);
 +                if unordered {
 +                    global.set_unordered();
 +                }

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from 52c5c10 to d28748f Compare November 15, 2026 00:26
@github-actions

Copy link
Copy Markdown
range-diff for force push 52c5c10828 → d28748fca8 November 15, 2026 00:26 UTC: 1 modified; 1 commit; same base 80ea45da32

reproduce: git range-diff 80ea45d..52c5c10 80ea45d..d28748f

1:  52c5c10828 +336  -18 2f ! 1:  d28748fca8 +696 -113 3f reject malformed unordered PSBTs
1: 52c5c10828 ! 1: d28748fca8 reject malformed unordered PSBTs
@@ crates/concurrent-psbt/proptest-regressions/psbt/tx.txt (new)
 +cc d39ffeae915558d1179aff2afb90b65fc845e008dbbb2dd0dc24d7a65023d779 # shrinks to unordered = None, derivation = Some([])
 +cc bd945f0c444bba85866627d0b662f363d4830b01b2577cca95ef68a4e37bf632 # shrinks to seed_len = Some(0), input_key_len = None, output_key_len = None
 
+ ## crates/concurrent-psbt/src/psbt/keyed_set.rs ##
+@@ crates/concurrent-psbt/src/psbt/keyed_set.rs: impl<K: Hash + Eq, V> ResultKeyedSet<K, V> {
+         self.len().is_ok()
+     }
+ 
++    /// The entries, with those sharing a key joined into one.
++    pub(crate) fn entries(&self) -> impl Iterator<Item = (&K, &V)> {
++        self.entries.0.iter()
++    }
++
++    /// The entries, mutably, for marking fields that break a rule spanning
++    /// several entries.
++    pub(crate) fn entries_mut(&mut self) -> impl Iterator<Item = (&K, &mut V)> {
++        self.entries.0.iter_mut()
++    }
++
+     fn add_frozen(&mut self, keys: HashSet<K>) {
+         if !self.frozen.contains(&keys) {
+             self.frozen.push(keys);
+
  ## crates/concurrent-psbt/src/psbt/tx.rs ##
-@@ crates/concurrent-psbt/src/psbt/tx.rs: use psbt_v2::v2::Psbt;
+@@ crates/concurrent-psbt/src/psbt/tx.rs: use bitcoin::OutPoint;
+ use psbt_v2::v2::Psbt;
  
  use crate::lattice::join::Join;
++use crate::lattice::partial::{Conflict, JoinResult, PartialJoin};
  
 -use super::global::{Global, InvalidGlobal, ResultGlobal, SortSeed};
--use super::input::{DuplicateInput, Input, InputSet, ResultInputSet, SortKey};
 +use super::global::{Global, InvalidGlobal, ResultGlobal, SortKeyDerivation, SortSeed};
-+use super::input::{DuplicateInput, Input, InputSet, ResultInputSet, SortKey, out_point};
+ use super::input::{DuplicateInput, Input, InputSet, ResultInputSet, SortKey};
  use super::output::{DuplicateOutput, InvalidOutput, Output, OutputSet, ResultOutputSet, UniqueId};
  
- /// A BIP 370 PSBT decomposed into [`Global`], [`InputSet`], and [`OutputSet`], without ordering.
 @@ crates/concurrent-psbt/src/psbt/tx.rs: pub enum UnorderedPsbtError {
      DuplicateInput(OutPoint),
      /// Two outputs carry the same `PSBT_OUT_UNIQUE_ID`.
@@ crates/concurrent-psbt/src/psbt/tx.rs: pub enum UnorderedPsbtError {
 +    /// derived, but the input spending this outpoint has a `PSBT_IN_SORT_KEY`.
 +    UnexpectedInputSortKey(OutPoint),
 +    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` is `0x01`, so every sort key is
-+    /// derived, but the output at this position has a `PSBT_OUT_SORT_KEY`.
-+    UnexpectedOutputSortKey(usize),
++    /// derived, but the output with this unique ID has a `PSBT_OUT_SORT_KEY`.
++    UnexpectedOutputSortKey(UniqueId),
 +    /// Two inputs, or two outputs, have this explicit sort key.
 +    DuplicateSortKey(Vec<u8>),
  }
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl fmt::Display for UnorderedPsbtError
 +                f,
 +                "the input spending {outpoint} has a sort key but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x01"
 +            ),
-+            Self::UnexpectedOutputSortKey(index) => write!(
++            Self::UnexpectedOutputSortKey(unique_id) => write!(
 +                f,
-+                "output {index} has a sort key but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x01"
++                "the output with unique ID {:02x?} has a sort key but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x01",
++                unique_id.as_bytes()
 +            ),
 +            Self::DuplicateSortKey(key) => write!(f, "duplicate sort key {key:02x?}"),
          }
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl std::error::Error for UnorderedPsbtE
 +/// `tx_modifiable_flags` bit marking a `SIGHASH_SINGLE` signature (BIP 370).
 +const HAS_SIGHASH_SINGLE: u8 = 0x04;
 +
-+/// Check that a PSBT can be read as unordered: it is marked unordered, it does
-+/// not use `SIGHASH_SINGLE`, the sort fields present agree with
-+/// `PSBT_GLOBAL_SORT_KEY_DERIVATION`, and no two inputs or two outputs share an
-+/// explicit sort key.
-+fn validate_unordered(
-+    global: &Global,
-+    inputs: &[Input],
-+    outputs: &[Output],
-+) -> Result<(), UnorderedPsbtError> {
++/// Check that a PSBT can be read as unordered: it is marked unordered and it
++/// does not use `SIGHASH_SINGLE`.
++fn check_unordered(global: &Global) -> Result<(), UnorderedPsbtError> {
 +    if !global.is_unordered() {
 +        return Err(UnorderedPsbtError::NotUnordered);
 +    }
 +    if global.tx_modifiable_flags() & HAS_SIGHASH_SINGLE != 0 {
 +        return Err(UnorderedPsbtError::UnorderedSighashSingle);
 +    }
-+    match global.sort_key_derivation() {
-+        Some(SortKeyDerivation::Explicit) if global.sort_seed().is_some() => {
-+            return Err(UnorderedPsbtError::UnexpectedSortSeed);
-+        }
-+        Some(SortKeyDerivation::Derived) => {
-+            if let Some(input) = inputs.iter().find(|input| input.sort_key().is_some()) {
-+                return Err(UnorderedPsbtError::UnexpectedInputSortKey(out_point(input)));
-+            }
-+            if let Some(index) = outputs
-+                .iter()
-+                .position(|output| output.sort_key().is_some())
-+            {
-+                return Err(UnorderedPsbtError::UnexpectedOutputSortKey(index));
-+            }
-+        }
-+        _ => {}
++    Ok(())
++}
++
++/// The values a field may hold: its value, or every value of its conflict.
++fn values<V: PartialJoin>(field: &Option<JoinResult<V>>) -> std::slice::Iter<'_, V> {
++    match field {
++        None => [].iter(),
++        Some(Ok(value)) => std::slice::from_ref(value).iter(),
++        Some(Err(conflict)) => conflict.into_iter(),
 +    }
-+    duplicate_sort_key(inputs.iter().filter_map(|input| input.sort_key()))
-+        .or_else(|| duplicate_sort_key(outputs.iter().filter_map(|output| output.sort_key())))
-+        .map_or(Ok(()), |key| {
-+            Err(UnorderedPsbtError::DuplicateSortKey(key.to_vec()))
++}
++
++/// Make the field a conflict holding its values, which it stays under every
++/// later join. This is the join with the empty conflict, so marking a field
++/// twice is marking it once.
++fn mark<V: PartialJoin>(field: &mut Option<JoinResult<V>>) {
++    if let Some(result) = field.take() {
++        *field = Some(result.join(Err(Conflict::from_values([]))));
++    }
++}
++
++/// Mark every sort key if `derived`, since then no key may be explicit, and
++/// otherwise every key that another of the entries may also have. Return
++/// `true` if a key was marked.
++///
++/// A linear scan for each key: the entries are few, and the sets are private,
++/// so a lookup structure can replace it without changing callers.
++fn mark_sort_keys<'a>(
++    keys: impl Iterator<Item = &'a mut Option<JoinResult<SortKey>>>,
++    derived: bool,
++) -> bool {
++    let mut keys: Vec<_> = keys.filter(|key| key.is_some()).collect();
++    let broken: Vec<bool> = (0..keys.len())
++        .map(|i| {
++            derived
++                || (0..keys.len()).any(|j| {
++                    j != i && values(keys[i]).any(|key| values(keys[j]).any(|other| key == other))
++                })
 +        })
++        .collect();
++    let mut marked = false;
++    for (key, broken) in keys.iter_mut().zip(broken) {
++        if broken {
++            mark(key);
++            marked = true;
++        }
++    }
++    marked
 +}
 +
-+/// The first sort key that repeats, if any.
-+fn duplicate_sort_key<'a>(mut keys: impl Iterator<Item = &'a [u8]>) -> Option<&'a [u8]> {
-+    let mut seen = std::collections::HashSet::new();
-+    keys.find(|key| !seen.insert(*key))
++/// The entries whose sort keys are conflicts, with one of the values of each.
++fn marked_sort_keys<'a, K: 'a>(
++    entries: impl Iterator<Item = (&'a K, &'a Option<JoinResult<SortKey>>)>,
++) -> impl Iterator<Item = (&'a K, &'a [u8])> {
++    entries.filter_map(|(key, sort_key)| match sort_key {
++        Some(Err(conflict)) => conflict
++            .into_iter()
++            .next()
++            .map(|sort_key| (key, sort_key.as_bytes())),
++        _ => None,
++    })
 +}
  
  impl UnorderedPsbt {
      /// Parse a v2 PSBT into unordered representation.
-@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
+     ///
++    /// This is [`ResultUnorderedPsbt::try_from_psbt`], then
++    /// [`try_unwrap`](ResultUnorderedPsbt::try_unwrap), so a PSBT breaking the
++    /// rules of `PSBT_GLOBAL_SORT_KEY_DERIVATION` is rejected exactly when
++    /// joining it would leave conflicts.
++    ///
++    /// # Errors
++    /// Returns the errors of [`ResultUnorderedPsbt::try_from_psbt`]. Then
++    /// returns [`UnorderedPsbtError::UnexpectedSortSeed`] for a seed under
++    /// derivation `0x00`, then under derivation `0x01`
++    /// [`UnorderedPsbtError::UnexpectedInputSortKey`] for the smallest outpoint
++    /// whose input has a sort key, or
++    /// [`UnorderedPsbtError::UnexpectedOutputSortKey`] for the smallest unique
++    /// ID whose output has one. Otherwise returns
++    /// [`UnorderedPsbtError::DuplicateSortKey`] for the smallest sort key that
++    /// repeats among the inputs, then among the outputs.
++    pub fn try_from_psbt(psbt: Psbt) -> Result<Self, UnorderedPsbtError> {
++        ResultUnorderedPsbt::try_from_psbt(psbt)?
++            .try_unwrap()
++            .map_err(|psbt| psbt.sort_rule_error())
++    }
++
++    /// The global fields.
++    pub fn global(&self) -> &Global {
++        &self.global
++    }
++
++    /// The inputs, keyed by outpoint.
++    pub fn inputs(&self) -> &InputSet {
++        &self.inputs
++    }
++
++    /// The outputs, keyed by unique ID.
++    pub fn outputs(&self) -> &OutputSet {
++        &self.outputs
++    }
++
++    /// Convert to a BIP 370 [`Psbt`].
++    ///
++    /// The inputs and outputs come out in an arbitrary order, so equal
++    /// values may serialize differently. Use `Sorter` to order them
++    /// deterministically before signing or comparing serializations.
++    pub fn into_psbt(self) -> Psbt {
++        let inputs: Vec<_> = self.inputs.into_iter().map(Into::into).collect();
++        let outputs: Vec<_> = self.outputs.into_iter().map(Into::into).collect();
++        Psbt {
++            global: self.global.into_v2(inputs.len(), outputs.len()),
++            inputs,
++            outputs,
++        }
++    }
++
++    /// Lift this [`UnorderedPsbt`] into the result domain as a [`ResultUnorderedPsbt`] with all fields `Ok`.
++    pub fn wrap(self) -> ResultUnorderedPsbt {
++        ResultUnorderedPsbt {
++            global: self.global.wrap(),
++            inputs: self.inputs.wrap(),
++            outputs: self.outputs.wrap(),
++        }
++        .enforce_sort_rules()
++    }
++}
++
++impl Join for ResultUnorderedPsbt {
++    fn join(self, other: Self) -> Self {
++        ResultUnorderedPsbt {
++            global: self.global.join(other.global),
++            inputs: self.inputs.join(other.inputs),
++            outputs: self.outputs.join(other.outputs),
++        }
++        .enforce_sort_rules()
++    }
++}
++
++impl ResultUnorderedPsbt {
++    /// Parse a v2 PSBT directly into the result domain.
++    ///
+     /// Two inputs spending the same outpoint, or two outputs sharing a unique
+     /// ID, are rejected rather than joined. Such a PSBT is invalid, and
      /// joining the duplicates would hide the problem unless their fields
      /// conflicted.
      ///
 +    /// The PSBT must be marked unordered, since reading an ordered PSBT as
 +    /// unordered would discard its order.
++    ///
++    /// A sort field that breaks the rules of
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` is not an error here but a conflict,
++    /// as it would be after a join. See
++    /// [`UnorderedPsbt::try_from_psbt`] for the errors these conflicts become.
 +    ///
      /// # Errors
      /// Returns a count mismatch if the declared input or output count is not
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 +    ///
 +    /// Then returns [`UnorderedPsbtError::NotUnordered`] for an ordered PSBT,
 +    /// [`UnorderedPsbtError::UnorderedSighashSingle`] if the `SIGHASH_SINGLE`
-+    /// flag is set, [`UnorderedPsbtError::UnexpectedSortSeed`],
-+    /// [`UnorderedPsbtError::UnexpectedInputSortKey`] or
-+    /// [`UnorderedPsbtError::UnexpectedOutputSortKey`] for a sort field that
-+    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` rules out, and
-+    /// [`UnorderedPsbtError::DuplicateSortKey`] for the first sort key that
-+    /// repeats among the inputs, then among the outputs. Finally returns the
-+    /// first input whose outpoint repeats, then the first unique ID that
-+    /// repeats.
++    /// flag is set, and finally the first input whose outpoint repeats, then
++    /// the first unique ID that repeats.
      pub fn try_from_psbt(psbt: Psbt) -> Result<Self, UnorderedPsbtError> {
          let Psbt {
              global,
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
                      .map_err(|error| UnorderedPsbtError::invalid_output(index, error))
              })
              .collect::<Result<Vec<_>, _>>()?;
-+        validate_unordered(&global, &inputs, &outputs)?;
++        check_unordered(&global)?;
 +
 +        let inputs = InputSet::try_from_inputs(inputs)?;
 +        let inputs = if global.tx_modifiable_flags() & INPUTS_MODIFIABLE == 0 {
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
          let outputs = OutputSet::try_from_outputs(outputs)?;
          let outputs = if global.tx_modifiable_flags() & OUTPUTS_MODIFIABLE == 0 {
              outputs.freeze()
+@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
+             outputs
+         };
+ 
+-        Ok(Self {
++        Ok(UnorderedPsbt {
+             global,
+             inputs,
+             outputs,
+-        })
+-    }
+-
+-    /// The global fields.
+-    pub fn global(&self) -> &Global {
+-        &self.global
+-    }
+-
+-    /// The inputs, keyed by outpoint.
+-    pub fn inputs(&self) -> &InputSet {
+-        &self.inputs
+-    }
+-
+-    /// The outputs, keyed by unique ID.
+-    pub fn outputs(&self) -> &OutputSet {
+-        &self.outputs
++        }
++        .wrap())
+     }
+ 
+-    /// Convert to a BIP 370 [`Psbt`].
++    /// Mark the sort fields that break the rules of
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` as conflicts: the seed if the
++    /// derivation may be `0x00`, every explicit sort key if it may be `0x01`,
++    /// and an explicit sort key that another input, or another output, may also
++    /// have. The derivation is marked with them, since together they are
++    /// invalid.
+     ///
+-    /// The inputs and outputs come out in an arbitrary order, so equal
+-    /// values may serialize differently. Use `Sorter` to order them
+-    /// deterministically before signing or comparing serializations.
+-    pub fn into_psbt(self) -> Psbt {
+-        let inputs: Vec<_> = self.inputs.into_iter().map(Into::into).collect();
+-        let outputs: Vec<_> = self.outputs.into_iter().map(Into::into).collect();
+-        Psbt {
+-            global: self.global.into_v2(inputs.len(), outputs.len()),
+-            inputs,
+-            outputs,
++    /// The rules read the values a field may hold, which joins only add to, so
++    /// a marked field stays marked under later joins. Marking keeps the values,
++    /// so marking again marks nothing new. Marking after every join therefore
++    /// keeps it a join.
++    fn enforce_sort_rules(mut self) -> Self {
++        let may_be =
++            |derivation| values(&self.global.sort_key_derivation).any(|value| *value == derivation);
++        let derived = may_be(SortKeyDerivation::Derived);
++        let seed_broken = may_be(SortKeyDerivation::Explicit) && self.global.sort_seed.is_some();
++        if seed_broken {
++            mark(&mut self.global.sort_seed);
+         }
+-    }
+-
+-    /// Lift this [`UnorderedPsbt`] into the result domain as a [`ResultUnorderedPsbt`] with all fields `Ok`.
+-    pub fn wrap(self) -> ResultUnorderedPsbt {
+-        ResultUnorderedPsbt {
+-            global: self.global.wrap(),
+-            inputs: self.inputs.wrap(),
+-            outputs: self.outputs.wrap(),
++        let inputs_broken = mark_sort_keys(
++            self.inputs
++                .0
++                .entries_mut()
++                .map(|(_, input)| &mut input.sort_key),
++            derived,
++        );
++        let outputs_broken = mark_sort_keys(
++            self.outputs
++                .0
++                .entries_mut()
++                .map(|(_, output)| &mut output.sort_key),
++            derived,
++        );
++        if seed_broken || inputs_broken || outputs_broken {
++            mark(&mut self.global.sort_key_derivation);
+         }
++        self
+     }
+-}
+ 
+-impl Join for ResultUnorderedPsbt {
+-    fn join(self, other: Self) -> Self {
+-        ResultUnorderedPsbt {
+-            global: self.global.join(other.global),
+-            inputs: self.inputs.join(other.inputs),
+-            outputs: self.outputs.join(other.outputs),
++    /// The rule that a PSBT read by [`try_from_psbt`](Self::try_from_psbt)
++    /// breaks, if it has conflicts. Reading joins nothing, so its only
++    /// conflicts are the sort fields that
++    /// [`enforce_sort_rules`](Self::enforce_sort_rules) marked, each holding
++    /// the one value read.
++    fn sort_rule_error(&self) -> UnorderedPsbtError {
++        if matches!(self.global.sort_seed, Some(Err(_))) {
++            return UnorderedPsbtError::UnexpectedSortSeed;
+         }
+-    }
+-}
+-
+-impl ResultUnorderedPsbt {
+-    /// Parse a v2 PSBT directly into the result domain, as
+-    /// [`UnorderedPsbt::try_from_psbt`] then [`wrap`](UnorderedPsbt::wrap).
+-    ///
+-    /// # Errors
+-    /// Returns the errors of [`UnorderedPsbt::try_from_psbt`].
+-    pub fn try_from_psbt(psbt: Psbt) -> Result<Self, UnorderedPsbtError> {
+-        UnorderedPsbt::try_from_psbt(psbt).map(UnorderedPsbt::wrap)
++        let inputs = || {
++            marked_sort_keys(
++                self.inputs
++                    .0
++                    .entries()
++                    .map(|(outpoint, input)| (outpoint, &input.sort_key)),
++            )
++        };
++        let outputs = || {
++            marked_sort_keys(
++                self.outputs
++                    .0
++                    .entries()
++                    .map(|(unique_id, output)| (unique_id, &output.sort_key)),
++            )
++        };
++        if values(&self.global.sort_key_derivation)
++            .any(|value| *value == SortKeyDerivation::Derived)
++        {
++            return match inputs().map(|(outpoint, _)| *outpoint).min() {
++                Some(outpoint) => UnorderedPsbtError::UnexpectedInputSortKey(outpoint),
++                None => UnorderedPsbtError::UnexpectedOutputSortKey(
++                    outputs()
++                        .map(|(unique_id, _)| unique_id)
++                        .min_by_key(|unique_id| unique_id.as_bytes())
++                        .expect("a sort key under derivation 0x01 was marked")
++                        .clone(),
++                ),
++            };
++        }
++        let smallest = |keys: &mut dyn Iterator<Item = &[u8]>| keys.min().map(<[u8]>::to_vec);
++        UnorderedPsbtError::DuplicateSortKey(
++            smallest(&mut inputs().map(|(_, key)| key))
++                .or_else(|| smallest(&mut outputs().map(|(_, key)| key)))
++                .expect("a repeated sort key was marked"),
++        )
+     }
+ 
+     /// Return `true` if every field across global, inputs, and outputs is conflict-free.
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
          output
      }
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                    ),
 +                ),
 +                (
-+                    UnorderedPsbtError::UnexpectedOutputSortKey(1),
-+                    "output 1 has a sort key but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x01"
++                    UnorderedPsbtError::UnexpectedOutputSortKey(UniqueId::new(vec![0xab])),
++                    "the output with unique ID [ab] has a sort key but PSBT_GLOBAL_SORT_KEY_DERIVATION is 0x01"
 +                        .to_string(),
 +                ),
 +                (
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                        vec![],
 +                        vec![output(1, None), output(2, Some(0))],
 +                    ),
-+                    Err(UnorderedPsbtError::UnexpectedOutputSortKey(1)),
++                    Err(UnorderedPsbtError::UnexpectedOutputSortKey(UniqueId::new(
++                        vec![2],
++                    ))),
 +                ),
 +                (
 +                    v2_psbt_with(
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                ),
 +            ];
 +            for (psbt, expected) in cases {
++                // Reading into the result domain turns a broken sort rule into
++                // conflicts, the derivation among them, rather than an error.
++                let result = ResultUnorderedPsbt::try_from_psbt(psbt.clone());
++                match &expected {
++                    Ok(()) => assert!(result.unwrap().is_ok()),
++                    Err(
++                        UnorderedPsbtError::NotUnordered
++                        | UnorderedPsbtError::UnorderedSighashSingle,
++                    ) => {
++                        assert_eq!(result.map(|_| ()), expected);
++                    }
++                    Err(_) => {
++                        let result = result.unwrap();
++                        assert!(matches!(result.global.sort_key_derivation, Some(Err(_))));
++                        assert!(!result.is_ok());
++                    }
++                }
 +                assert_eq!(UnorderedPsbt::try_from_psbt(psbt).map(|_| ()), expected);
 +            }
 +        }
++
++        #[test]
++        fn joins_that_break_the_sort_rules_mark_the_fields_that_break_them() {
++            let explicit = {
++                let mut psbt = singleton(1);
++                psbt.global
++                    .set_sort_key_derivation(SortKeyDerivation::Explicit);
++                psbt.wrap()
++            };
++            let seed = SortSeed::try_from(vec![0; 16]).unwrap();
++            let seeded = {
++                let mut psbt = singleton(1);
++                psbt.global.set_sort_seed(seed.clone());
++                psbt.wrap()
++            };
++            let joined = explicit.join(seeded);
++            assert_eq!(
++                joined.global.sort_key_derivation,
++                Some(Err(Conflict::from_values([SortKeyDerivation::Explicit])))
++            );
++            assert_eq!(
++                joined.global.sort_seed,
++                Some(Err(Conflict::from_values([seed])))
++            );
++            assert!(joined.clone().try_unwrap().is_err());
++
++            // Without a derivation, only the repeated keys are marked.
++            let key = SortKey::try_from(vec![0]).unwrap();
++            let keyed = |byte| {
++                let mut input = Input::new(&outpoint(byte));
++                input.set_sort_key(key.clone());
++                let mut psbt = singleton(byte);
++                psbt.inputs = InputSet::try_from_inputs([input]).unwrap();
++                psbt.wrap()
++            };
++            let joined = keyed(1).join(keyed(2));
++            assert_eq!(joined.global.sort_key_derivation, None);
++            for (_, input) in joined.inputs.0.entries() {
++                assert_eq!(
++                    input.sort_key,
++                    Some(Err(Conflict::from_values([key.clone()])))
++                );
++            }
++            assert!(!joined.is_ok());
++        }
 +
          #[test]
          fn serialized_psbts_with_disjoint_entries_join_into_their_union() {
              let joined = (1..=3)
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
-                         }))
+         /// An UnorderedPsbt with either transaction version, any modifiable
+         /// flags, and up to three inputs and outputs.
+         fn arb_unordered_psbt() -> impl Strategy<Value = UnorderedPsbt> {
++            arb_psbt(false)
++        }
++
++        /// As [`arb_unordered_psbt`], with any sort fields that
++        /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` allows, from small domains so
++        /// that joins break the rules.
++        fn arb_sorted_psbt() -> impl Strategy<Value = UnorderedPsbt> {
++            arb_psbt(true)
++        }
++
++        /// Drop the keys of `keep_none`, and each key already kept.
++        fn distinct_keys(keep_none: bool) -> impl FnMut(Option<u8>) -> Option<SortKey> {
++            let mut seen = std::collections::HashSet::new();
++            move |key| {
++                key.filter(|key| !keep_none && seen.insert(*key))
++                    .map(|key| SortKey::try_from(vec![key]).expect("one byte"))
++            }
++        }
++
++        fn arb_psbt(sort_fields: bool) -> impl Strategy<Value = UnorderedPsbt> {
+             (
+                 proptest::bool::ANY, // tx_version: ONE or TWO
+                 0u8..4,              // tx_modifiable_flags
+-                proptest::collection::hash_set((0u8..5, 0u32..2), 0..=3), // inputs: (txid_byte, vout)
+-                proptest::collection::hash_set(0u8..10, 0..=3),           // outputs: uid_byte
++                // inputs: (txid_byte, vout) to sort key
++                proptest::collection::hash_map(
++                    (0u8..5, 0u32..2),
++                    proptest::option::of(0u8..3),
++                    0..=3,
++                ),
++                // outputs: uid_byte to sort key
++                proptest::collection::hash_map(0u8..10, proptest::option::of(0u8..3), 0..=3),
++                proptest::option::of(prop_oneof![
++                    Just(SortKeyDerivation::Explicit),
++                    Just(SortKeyDerivation::Derived),
++                ]),
++                proptest::option::of(0u8..2), // sort seed byte
+             )
+-                .prop_map(|(use_v1, flags, input_specs, output_uids)| {
+-                    use bitcoin::hashes::Hash;
+-
+-                    let inputs = InputSet::try_from_inputs(input_specs.into_iter().map(
+-                        |(txid_byte, vout)| {
+-                            Input::new(&bitcoin::OutPoint {
+-                                txid: bitcoin::Txid::from_byte_array([txid_byte; 32]),
+-                                vout,
+-                            })
+-                        },
+-                    ))
+-                    .expect("distinct outpoints");
+-
+-                    let outputs =
+-                        OutputSet::try_from_outputs(output_uids.into_iter().map(|uid_byte| {
+-                            Output::new(
+-                                UniqueId::new(vec![uid_byte; 16]),
+-                                bitcoin::Amount::from_sat(100_000),
+-                                bitcoin::ScriptBuf::new_op_return([uid_byte; 20]),
+-                            )
+-                        }))
++                .prop_map(
++                    move |(use_v1, flags, input_specs, output_specs, derivation, seed)| {
++                        use bitcoin::hashes::Hash;
++
++                        let derivation = derivation.filter(|_| sort_fields);
++                        let no_keys =
++                            !sort_fields || derivation == Some(SortKeyDerivation::Derived);
++
++                        let mut input_key = distinct_keys(no_keys);
++                        let inputs = InputSet::try_from_inputs(input_specs.into_iter().map(
++                            |((txid_byte, vout), key)| {
++                                let mut input = Input::new(&bitcoin::OutPoint {
++                                    txid: bitcoin::Txid::from_byte_array([txid_byte; 32]),
++                                    vout,
++                                });
++                                if let Some(key) = input_key(key) {
++                                    input.set_sort_key(key);
++                                }
++                                input
++                            },
++                        ))
++                        .expect("distinct outpoints");
++
++                        let mut output_key = distinct_keys(no_keys);
++                        let outputs = OutputSet::try_from_outputs(output_specs.into_iter().map(
++                            |(uid_byte, key)| {
++                                let mut output = Output::new(
++                                    UniqueId::new(vec![uid_byte; 16]),
++                                    bitcoin::Amount::from_sat(100_000),
++                                    bitcoin::ScriptBuf::new_op_return([uid_byte; 20]),
++                                );
++                                if let Some(key) = output_key(key) {
++                                    output.set_sort_key(key);
++                                }
++                                output
++                            },
++                        ))
                          .expect("distinct UIDs");
  
 -                    let mut global = Global::default();
-+                    let mut global = unordered_global();
-                     global.set_tx_version(if use_v1 {
-                         transaction::Version::ONE
-                     } else {
+-                    global.set_tx_version(if use_v1 {
+-                        transaction::Version::ONE
+-                    } else {
+-                        transaction::Version::TWO
+-                    });
+-                    global.set_tx_modifiable_flags(flags);
+-                    let psbt = UnorderedPsbt {
+-                        global,
+-                        inputs,
+-                        outputs,
+-                    };
+-                    // Reparse so the sets are frozen according to the flags.
+-                    UnorderedPsbt::try_from_psbt(psbt.into_psbt()).expect("a valid unordered PSBT")
+-                })
++                        let mut global = unordered_global();
++                        global.set_tx_version(if use_v1 {
++                            transaction::Version::ONE
++                        } else {
++                            transaction::Version::TWO
++                        });
++                        global.set_tx_modifiable_flags(flags);
++                        if let Some(derivation) = derivation {
++                            global.set_sort_key_derivation(derivation);
++                        }
++                        let seed = seed.filter(|_| {
++                            sort_fields && derivation != Some(SortKeyDerivation::Explicit)
++                        });
++                        if let Some(byte) = seed {
++                            global.set_sort_seed(
++                                SortSeed::try_from(vec![byte; 16]).expect("16 bytes"),
++                            );
++                        }
++                        let psbt = UnorderedPsbt {
++                            global,
++                            inputs,
++                            outputs,
++                        };
++                        // Reparse so the sets are frozen according to the flags.
++                        UnorderedPsbt::try_from_psbt(psbt.into_psbt())
++                            .expect("a valid unordered PSBT")
++                    },
++                )
+         }
+ 
+         /// A wrapped PSBT, or the join of two independently drawn ones, which
+         /// may conflict.
+         fn arb_result_unordered_psbt() -> impl Strategy<Value = ResultUnorderedPsbt> {
+             prop_oneof![
+-                arb_unordered_psbt().prop_map(|p| p.wrap()),
+-                (arb_unordered_psbt(), arb_unordered_psbt())
+-                    .prop_map(|(a, b)| a.wrap().join(b.wrap())),
++                arb_sorted_psbt().prop_map(|p| p.wrap()),
++                (arb_sorted_psbt(), arb_sorted_psbt()).prop_map(|(a, b)| a.wrap().join(b.wrap())),
+             ]
+         }
+ 
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+ 
+         proptest! {
+             #[test]
+-            fn wrap_try_unwrap_roundtrip(a in arb_unordered_psbt()) {
++            fn wrap_try_unwrap_roundtrip(a in arb_sorted_psbt()) {
+                 prop_assert_eq!(a.clone().wrap().try_unwrap(), Ok(a));
+             }
+ 
+             #[test]
+-            fn result_try_from_psbt_agrees_with_wrap(a in arb_unordered_psbt()) {
++            fn result_try_from_psbt_agrees_with_wrap(a in arb_sorted_psbt()) {
+                 prop_assert_eq!(
+                     ResultUnorderedPsbt::try_from_psbt(a.clone().into_psbt()),
+                     Ok(a.wrap())
 @@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                          Some(format!("{len} outputs but has {index}")),
                      ),
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                    (UnorderedPsbtError::UnorderedSighashSingle, None),
 +                    (UnorderedPsbtError::UnexpectedSortSeed, None),
 +                    (UnorderedPsbtError::UnexpectedInputSortKey(outpoint), Some(outpoint.to_string())),
-+                    (UnorderedPsbtError::UnexpectedOutputSortKey(index), Some(index.to_string())),
++                    (UnorderedPsbtError::UnexpectedOutputSortKey(UniqueId::new(value.clone())), Some(bytes.clone())),
 +                    (UnorderedPsbtError::DuplicateSortKey(value.clone()), Some(format!("{value:02x?}"))),
                      // The unique ID is opaque bytes, so the message leaves it out.
                      (UnorderedPsbtError::DuplicateOutputUniqueId(UniqueId::new(value)), None),
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +            }
 +
 +            #[test]
-+            fn try_from_psbt_rejects_the_first_repeated_sort_key(
-+                distinct in proptest::collection::hash_set(any::<u8>(), 1..=3),
-+                repeat in any::<proptest::sample::Index>(),
-+                tail in proptest::collection::vec(any::<u8>(), 0..=2),
++            fn try_from_psbt_rejects_the_smallest_repeated_sort_key(
++                keys in proptest::collection::vec(0u8..4, 0..=5),
 +                on_outputs in proptest::bool::ANY,
 +            ) {
-+                let distinct: Vec<u8> = distinct.into_iter().collect();
-+                let repeated = distinct[repeat.index(distinct.len())];
-+                let keys: Vec<u8> = distinct.iter().copied().chain([repeated]).chain(tail).collect();
++                let repeated = keys
++                    .iter()
++                    .filter(|key| keys.iter().filter(|other| other == key).count() > 1)
++                    .min()
++                    .copied();
 +                let sort_key = |key| SortKey::try_from(vec![key]).expect("one byte");
 +                let entries = (0u8..).zip(keys);
 +                let psbt = if on_outputs {
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +                };
 +                prop_assert_eq!(
 +                    UnorderedPsbt::try_from_psbt(psbt).map(|_| ()),
-+                    Err(UnorderedPsbtError::DuplicateSortKey(vec![repeated]))
++                    repeated.map_or(Ok(()), |key| Err(UnorderedPsbtError::DuplicateSortKey(vec![key])))
 +                );
 +            }
 +

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from d28748f to a69dec9 Compare November 15, 2026 02:13
@github-actions

Copy link
Copy Markdown
range-diff for force push d28748fca8 → a69dec9481 November 15, 2026 02:13 UTC: 1 modified; 1 commit; base 80ea45da32 → 00ec300c1b (diverged, 10 ahead and 10 behind)

reproduce: git range-diff 80ea45d..d28748f 00ec300..a69dec9

1:  d28748fca8 +696 -113 3f ! 1:  a69dec9481 +696 -113 3f reject malformed unordered PSBTs
1: d28748fca8 ! 1: a69dec9481 reject malformed unordered PSBTs
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
                  prop_assert_eq!(a.clone().wrap().try_unwrap(), Ok(a));
              }
  
+@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
+             }
+ 
              #[test]
 -            fn result_try_from_psbt_agrees_with_wrap(a in arb_unordered_psbt()) {
 +            fn result_try_from_psbt_agrees_with_wrap(a in arb_sorted_psbt()) {

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from a69dec9 to 496f7b9 Compare November 15, 2026 23:52
@github-actions

Copy link
Copy Markdown
range-diff for force push a69dec9481 → 496f7b9cd8 November 15, 2026 23:52 UTC: 1 unchanged; 1 commit; base 00ec300c1b → 6dcdbc01d9 (diverged, 10 ahead and 10 behind)

reproduce: git range-diff 00ec300..a69dec9 6dcdbc0..496f7b9

1:  a69dec9481 +696 -113 3f = 1:  496f7b9cd8 +696 -113 3f reject malformed unordered PSBTs

@github-actions

Copy link
Copy Markdown
range-diff for force push a69dec9481 → 496f7b9cd8 November 15, 2026 23:52 UTC: 1 unchanged; 1 commit; base 00ec300c1b → 6dcdbc01d9 (diverged, 10 ahead and 10 behind)

reproduce: git range-diff 00ec300..a69dec9 6dcdbc0..496f7b9

1:  a69dec9481 +696 -113 3f = 1:  496f7b9cd8 +696 -113 3f reject malformed unordered PSBTs

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from 496f7b9 to f1e8135 Compare November 16, 2026 00:16
@github-actions

Copy link
Copy Markdown
range-diff for force push 496f7b9cd8 → f1e8135717 November 16, 2026 00:16 UTC: 1 unchanged; 1 commit; base 6dcdbc01d9 → 1f4cc5b213 (diverged, 7 ahead and 7 behind)

reproduce: git range-diff 6dcdbc0..496f7b9 1f4cc5b..f1e8135

1:  496f7b9cd8 +696 -113 3f = 1:  f1e8135717 +696 -113 3f reject malformed unordered PSBTs

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from f1e8135 to 3898b66 Compare November 16, 2026 03:23
@github-actions

Copy link
Copy Markdown
range-diff for force push f1e8135717 → 3898b66476 November 16, 2026 03:23 UTC: 1 modified; 1 commit; base 1f4cc5b213 → c42d27aab8 (diverged, 10 ahead and 10 behind)

reproduce: git range-diff 1f4cc5b..f1e8135 c42d27a..3898b66

1:  f1e8135717 +696 -113 3f ! 1:  3898b66476 +715 -124 4f reject malformed unordered PSBTs
1: f1e8135717 ! 1: 3898b66476 reject malformed unordered PSBTs
@@ crates/concurrent-psbt/src/psbt/tx.rs: use bitcoin::OutPoint;
  
  use crate::lattice::join::Join;
 +use crate::lattice::partial::{Conflict, JoinResult, PartialJoin};
+ use crate::{Conflicts, Lift, ResultWrapped};
  
+ use super::conflicts::PsbtConflict;
 -use super::global::{Global, InvalidGlobal, ResultGlobal, SortSeed};
 +use super::global::{Global, InvalidGlobal, ResultGlobal, SortKeyDerivation, SortSeed};
  use super::input::{DuplicateInput, Input, InputSet, ResultInputSet, SortKey};
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl std::error::Error for UnorderedPsbtE
  impl UnorderedPsbt {
      /// Parse a v2 PSBT into unordered representation.
      ///
+-    /// Two inputs spending the same outpoint, or two outputs sharing a unique
+-    /// ID, are rejected rather than joined. Such a PSBT is invalid, and
+-    /// joining the duplicates would hide the problem unless their fields
+-    /// conflicted.
 +    /// This is [`ResultUnorderedPsbt::try_from_psbt`], then
 +    /// [`try_unwrap`](ResultUnorderedPsbt::try_unwrap), so a PSBT breaking the
 +    /// rules of `PSBT_GLOBAL_SORT_KEY_DERIVATION` is rejected exactly when
 +    /// joining it would leave conflicts.
-+    ///
-+    /// # Errors
+     ///
+     /// # Errors
+-    /// Returns a count mismatch if the declared input or output count is not
+-    /// the number of inputs or outputs, which only a `Psbt` assembled by hand
+-    /// can have. Otherwise returns a malformed global sort field, then the
+-    /// first input whose sort key is longer than [`SortKey::MAX_LEN`] bytes,
+-    /// then the first input whose outpoint repeats, then the first output
+-    /// whose `PSBT_OUT_UNIQUE_ID` is missing, empty or longer than
+-    /// [`UniqueId::MAX_LEN`] bytes, or whose sort key is longer than
+-    /// [`SortKey::MAX_LEN`] bytes, then the first unique ID that repeats.
 +    /// Returns the errors of [`ResultUnorderedPsbt::try_from_psbt`]. Then
 +    /// returns [`UnorderedPsbtError::UnexpectedSortSeed`] for a seed under
 +    /// derivation `0x00`, then under derivation `0x01`
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl std::error::Error for UnorderedPsbtE
 +    /// ID whose output has one. Otherwise returns
 +    /// [`UnorderedPsbtError::DuplicateSortKey`] for the smallest sort key that
 +    /// repeats among the inputs, then among the outputs.
-+    pub fn try_from_psbt(psbt: Psbt) -> Result<Self, UnorderedPsbtError> {
+     pub fn try_from_psbt(psbt: Psbt) -> Result<Self, UnorderedPsbtError> {
+-        let Psbt {
+-            global,
+-            inputs,
+-            outputs,
+-        } = psbt;
+-        if global.input_count != inputs.len() {
+-            return Err(UnorderedPsbtError::InputCountMismatch {
+-                declared: global.input_count,
+-                found: inputs.len(),
+-            });
+-        }
+-        if global.output_count != outputs.len() {
+-            return Err(UnorderedPsbtError::OutputCountMismatch {
+-                declared: global.output_count,
+-                found: outputs.len(),
+-            });
+-        }
+-
+-        let global = Global::try_from(global)?;
+-        let inputs = inputs
+-            .into_iter()
+-            .map(|input| {
+-                let outpoint = OutPoint {
+-                    txid: input.previous_txid,
+-                    vout: input.spent_output_index,
+-                };
+-                Input::try_from(input)
+-                    .map_err(|_| UnorderedPsbtError::InputSortKeyTooLong(outpoint))
+-            })
+-            .collect::<Result<Vec<_>, _>>()?;
+-        let inputs = InputSet::try_from_inputs(inputs)?;
+-        let inputs = if global.tx_modifiable_flags() & INPUTS_MODIFIABLE == 0 {
+-            inputs.freeze()
+-        } else {
+-            inputs
+-        };
+-        let outputs = outputs
+-            .into_iter()
+-            .enumerate()
+-            .map(|(index, output)| {
+-                Output::try_from(output)
+-                    .map_err(|error| UnorderedPsbtError::invalid_output(index, error))
+-            })
+-            .collect::<Result<Vec<_>, _>>()?;
+-        let outputs = OutputSet::try_from_outputs(outputs)?;
+-        let outputs = if global.tx_modifiable_flags() & OUTPUTS_MODIFIABLE == 0 {
+-            outputs.freeze()
+-        } else {
+-            outputs
+-        };
+-
+-        Ok(Self {
+-            global,
+-            inputs,
+-            outputs,
+-        })
 +        ResultUnorderedPsbt::try_from_psbt(psbt)?
 +            .try_unwrap()
 +            .map_err(|psbt| psbt.sort_rule_error())
-+    }
-+
-+    /// The global fields.
-+    pub fn global(&self) -> &Global {
-+        &self.global
-+    }
-+
-+    /// The inputs, keyed by outpoint.
-+    pub fn inputs(&self) -> &InputSet {
-+        &self.inputs
-+    }
-+
-+    /// The outputs, keyed by unique ID.
-+    pub fn outputs(&self) -> &OutputSet {
-+        &self.outputs
-+    }
-+
-+    /// Convert to a BIP 370 [`Psbt`].
-+    ///
-+    /// The inputs and outputs come out in an arbitrary order, so equal
-+    /// values may serialize differently. Use `Sorter` to order them
-+    /// deterministically before signing or comparing serializations.
-+    pub fn into_psbt(self) -> Psbt {
-+        let inputs: Vec<_> = self.inputs.into_iter().map(Into::into).collect();
-+        let outputs: Vec<_> = self.outputs.into_iter().map(Into::into).collect();
-+        Psbt {
-+            global: self.global.into_v2(inputs.len(), outputs.len()),
-+            inputs,
-+            outputs,
-+        }
-+    }
-+
-+    /// Lift this [`UnorderedPsbt`] into the result domain as a [`ResultUnorderedPsbt`] with all fields `Ok`.
-+    pub fn wrap(self) -> ResultUnorderedPsbt {
-+        ResultUnorderedPsbt {
-+            global: self.global.wrap(),
-+            inputs: self.inputs.wrap(),
-+            outputs: self.outputs.wrap(),
-+        }
+     }
+ 
+     /// The global fields.
+@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
+             inputs: self.inputs.wrap(),
+             outputs: self.outputs.wrap(),
+         }
 +        .enforce_sort_rules()
-+    }
-+}
-+
-+impl Join for ResultUnorderedPsbt {
-+    fn join(self, other: Self) -> Self {
-+        ResultUnorderedPsbt {
-+            global: self.global.join(other.global),
-+            inputs: self.inputs.join(other.inputs),
-+            outputs: self.outputs.join(other.outputs),
-+        }
+     }
+ }
+ 
+@@ crates/concurrent-psbt/src/psbt/tx.rs: impl Join for ResultUnorderedPsbt {
+             inputs: self.inputs.join(other.inputs),
+             outputs: self.outputs.join(other.outputs),
+         }
 +        .enforce_sort_rules()
-+    }
-+}
-+
-+impl ResultUnorderedPsbt {
+     }
+ }
+ 
+@@ crates/concurrent-psbt/src/psbt/tx.rs: impl ResultUnorderedPsbt {
+             .chain(self.outputs.conflicts())
+     }
+ 
+-    /// Parse a v2 PSBT directly into the result domain, as
+-    /// [`UnorderedPsbt::try_from_psbt`] then [`wrap`](UnorderedPsbt::wrap).
 +    /// Parse a v2 PSBT directly into the result domain.
 +    ///
-     /// Two inputs spending the same outpoint, or two outputs sharing a unique
-     /// ID, are rejected rather than joined. Such a PSBT is invalid, and
-     /// joining the duplicates would hide the problem unless their fields
-     /// conflicted.
-     ///
++    /// Two inputs spending the same outpoint, or two outputs sharing a unique
++    /// ID, are rejected rather than joined. Such a PSBT is invalid, and
++    /// joining the duplicates would hide the problem unless their fields
++    /// conflicted.
++    ///
 +    /// The PSBT must be marked unordered, since reading an ordered PSBT as
 +    /// unordered would discard its order.
 +    ///
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl std::error::Error for UnorderedPsbtE
 +    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` is not an error here but a conflict,
 +    /// as it would be after a join. See
 +    /// [`UnorderedPsbt::try_from_psbt`] for the errors these conflicts become.
-+    ///
+     ///
      /// # Errors
-     /// Returns a count mismatch if the declared input or output count is not
-     /// the number of inputs or outputs, which only a `Psbt` assembled by hand
-     /// can have. Otherwise returns a malformed global sort field, then the
-     /// first input whose sort key is longer than [`SortKey::MAX_LEN`] bytes,
--    /// then the first input whose outpoint repeats, then the first output
--    /// whose `PSBT_OUT_UNIQUE_ID` is missing, empty or longer than
--    /// [`UniqueId::MAX_LEN`] bytes, or whose sort key is longer than
--    /// [`SortKey::MAX_LEN`] bytes, then the first unique ID that repeats.
+-    /// Returns the errors of [`UnorderedPsbt::try_from_psbt`].
++    /// Returns a count mismatch if the declared input or output count is not
++    /// the number of inputs or outputs, which only a `Psbt` assembled by hand
++    /// can have. Otherwise returns a malformed global sort field, then the
++    /// first input whose sort key is longer than [`SortKey::MAX_LEN`] bytes,
 +    /// then the first output whose `PSBT_OUT_UNIQUE_ID` is missing, empty or
 +    /// longer than [`UniqueId::MAX_LEN`] bytes, or whose sort key is longer
 +    /// than [`SortKey::MAX_LEN`] bytes.
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl std::error::Error for UnorderedPsbtE
 +    /// flag is set, and finally the first input whose outpoint repeats, then
 +    /// the first unique ID that repeats.
      pub fn try_from_psbt(psbt: Psbt) -> Result<Self, UnorderedPsbtError> {
-         let Psbt {
-             global,
-@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
-                     .map_err(|_| UnorderedPsbtError::InputSortKeyTooLong(outpoint))
-             })
-             .collect::<Result<Vec<_>, _>>()?;
--        let inputs = InputSet::try_from_inputs(inputs)?;
--        let inputs = if global.tx_modifiable_flags() & INPUTS_MODIFIABLE == 0 {
--            inputs.freeze()
--        } else {
--            inputs
--        };
-         let outputs = outputs
-             .into_iter()
-             .enumerate()
-@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
-                     .map_err(|error| UnorderedPsbtError::invalid_output(index, error))
-             })
-             .collect::<Result<Vec<_>, _>>()?;
+-        UnorderedPsbt::try_from_psbt(psbt).map(UnorderedPsbt::wrap)
++        let Psbt {
++            global,
++            inputs,
++            outputs,
++        } = psbt;
++        if global.input_count != inputs.len() {
++            return Err(UnorderedPsbtError::InputCountMismatch {
++                declared: global.input_count,
++                found: inputs.len(),
++            });
++        }
++        if global.output_count != outputs.len() {
++            return Err(UnorderedPsbtError::OutputCountMismatch {
++                declared: global.output_count,
++                found: outputs.len(),
++            });
++        }
++
++        let global = Global::try_from(global)?;
++        let inputs = inputs
++            .into_iter()
++            .map(|input| {
++                let outpoint = OutPoint {
++                    txid: input.previous_txid,
++                    vout: input.spent_output_index,
++                };
++                Input::try_from(input)
++                    .map_err(|_| UnorderedPsbtError::InputSortKeyTooLong(outpoint))
++            })
++            .collect::<Result<Vec<_>, _>>()?;
++        let outputs = outputs
++            .into_iter()
++            .enumerate()
++            .map(|(index, output)| {
++                Output::try_from(output)
++                    .map_err(|error| UnorderedPsbtError::invalid_output(index, error))
++            })
++            .collect::<Result<Vec<_>, _>>()?;
 +        check_unordered(&global)?;
 +
 +        let inputs = InputSet::try_from_inputs(inputs)?;
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 +        } else {
 +            inputs
 +        };
-         let outputs = OutputSet::try_from_outputs(outputs)?;
-         let outputs = if global.tx_modifiable_flags() & OUTPUTS_MODIFIABLE == 0 {
-             outputs.freeze()
-@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
-             outputs
-         };
- 
--        Ok(Self {
++        let outputs = OutputSet::try_from_outputs(outputs)?;
++        let outputs = if global.tx_modifiable_flags() & OUTPUTS_MODIFIABLE == 0 {
++            outputs.freeze()
++        } else {
++            outputs
++        };
++
 +        Ok(UnorderedPsbt {
-             global,
-             inputs,
-             outputs,
--        })
--    }
--
--    /// The global fields.
--    pub fn global(&self) -> &Global {
--        &self.global
--    }
--
--    /// The inputs, keyed by outpoint.
--    pub fn inputs(&self) -> &InputSet {
--        &self.inputs
--    }
--
--    /// The outputs, keyed by unique ID.
--    pub fn outputs(&self) -> &OutputSet {
--        &self.outputs
++            global,
++            inputs,
++            outputs,
 +        }
 +        .wrap())
-     }
- 
--    /// Convert to a BIP 370 [`Psbt`].
++    }
++
 +    /// Mark the sort fields that break the rules of
 +    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` as conflicts: the seed if the
 +    /// derivation may be `0x00`, every explicit sort key if it may be `0x01`,
 +    /// and an explicit sort key that another input, or another output, may also
 +    /// have. The derivation is marked with them, since together they are
 +    /// invalid.
-     ///
--    /// The inputs and outputs come out in an arbitrary order, so equal
--    /// values may serialize differently. Use `Sorter` to order them
--    /// deterministically before signing or comparing serializations.
--    pub fn into_psbt(self) -> Psbt {
--        let inputs: Vec<_> = self.inputs.into_iter().map(Into::into).collect();
--        let outputs: Vec<_> = self.outputs.into_iter().map(Into::into).collect();
--        Psbt {
--            global: self.global.into_v2(inputs.len(), outputs.len()),
--            inputs,
--            outputs,
++    ///
 +    /// The rules read the values a field may hold, which joins only add to, so
 +    /// a marked field stays marked under later joins. Marking keeps the values,
 +    /// so marking again marks nothing new. Marking after every join therefore
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 +        let seed_broken = may_be(SortKeyDerivation::Explicit) && self.global.sort_seed.is_some();
 +        if seed_broken {
 +            mark(&mut self.global.sort_seed);
-         }
--    }
--
--    /// Lift this [`UnorderedPsbt`] into the result domain as a [`ResultUnorderedPsbt`] with all fields `Ok`.
--    pub fn wrap(self) -> ResultUnorderedPsbt {
--        ResultUnorderedPsbt {
--            global: self.global.wrap(),
--            inputs: self.inputs.wrap(),
--            outputs: self.outputs.wrap(),
++        }
 +        let inputs_broken = mark_sort_keys(
 +            self.inputs
 +                .0
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 +        );
 +        if seed_broken || inputs_broken || outputs_broken {
 +            mark(&mut self.global.sort_key_derivation);
-         }
++        }
 +        self
-     }
--}
- 
--impl Join for ResultUnorderedPsbt {
--    fn join(self, other: Self) -> Self {
--        ResultUnorderedPsbt {
--            global: self.global.join(other.global),
--            inputs: self.inputs.join(other.inputs),
--            outputs: self.outputs.join(other.outputs),
++    }
++
 +    /// The rule that a PSBT read by [`try_from_psbt`](Self::try_from_psbt)
 +    /// breaks, if it has conflicts. Reading joins nothing, so its only
 +    /// conflicts are the sort fields that
@@ crates/concurrent-psbt/src/psbt/tx.rs: impl UnorderedPsbt {
 +    fn sort_rule_error(&self) -> UnorderedPsbtError {
 +        if matches!(self.global.sort_seed, Some(Err(_))) {
 +            return UnorderedPsbtError::UnexpectedSortSeed;
-         }
--    }
--}
--
--impl ResultUnorderedPsbt {
--    /// Parse a v2 PSBT directly into the result domain, as
--    /// [`UnorderedPsbt::try_from_psbt`] then [`wrap`](UnorderedPsbt::wrap).
--    ///
--    /// # Errors
--    /// Returns the errors of [`UnorderedPsbt::try_from_psbt`].
--    pub fn try_from_psbt(psbt: Psbt) -> Result<Self, UnorderedPsbtError> {
--        UnorderedPsbt::try_from_psbt(psbt).map(UnorderedPsbt::wrap)
++        }
 +        let inputs = || {
 +            marked_sort_keys(
 +                self.inputs
@@ crates/concurrent-psbt/src/psbt/tx.rs: mod tests {
 +
              #[test]
              fn is_ok_iff_try_unwrap_succeeds(r in arb_result_unordered_psbt()) {
-                 prop_assert_eq!(r.is_ok(), r.try_unwrap().is_ok());
+                 prop_assert_eq!(r.conflicts().next().is_none(), r.is_ok());
+
+ ## crates/concurrent-psbt/tests/conflicts.rs ##
+@@ crates/concurrent-psbt/tests/conflicts.rs: use concurrent_psbt::{Conflicts, Join, Lift, ResultWrapped};
+ 
+ #[cfg_attr(coverage_nightly, coverage(off))]
+ fn psbt(version: transaction::Version) -> UnorderedPsbt {
+-    UnorderedPsbt::try_from_psbt(psbt_v2::v2::Psbt {
++    let mut psbt = psbt_v2::v2::Psbt {
+         global: psbt_v2::v2::Global {
+             tx_version: version,
+             ..Default::default()
+         },
+         inputs: vec![],
+         outputs: vec![],
+-    })
+-    .unwrap()
++    };
++    psbt.global.proprietaries.insert(
++        psbt_v2::raw::ProprietaryKey {
++            prefix: concurrent_psbt::PROPRIETARY_PREFIX.to_vec(),
++            subtype: concurrent_psbt::global::PSBT_GLOBAL_TX_UNORDERED_SUBTYPE,
++            key: vec![],
++        },
++        vec![0x03],
++    );
++    UnorderedPsbt::try_from_psbt(psbt).unwrap()
+ }
+ 
+ #[cfg_attr(coverage_nightly, coverage(off))]

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from 3898b66 to 42aa094 Compare November 16, 2026 04:29
@github-actions

Copy link
Copy Markdown
range-diff for force push 3898b66476 → 42aa094bc9 November 16, 2026 04:37 UTC: 1 unchanged; 1 commit; base c42d27aab8 → cf4c10eb8b (diverged, 10 ahead and 10 behind)

reproduce: git range-diff c42d27a..3898b66 cf4c10e..42aa094

1:  3898b66476 +715 -124 4f = 1:  42aa094bc9 +715 -124 4f reject malformed unordered PSBTs

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from 42aa094 to 6f5ebba Compare November 16, 2026 04:58
@github-actions

Copy link
Copy Markdown
range-diff for force push 42aa094bc9 → 6f5ebba138 November 16, 2026 06:07 UTC: 1 unchanged; 1 commit; base cf4c10eb8b → 59080f841c (diverged, 10 ahead and 10 behind)

reproduce: git range-diff cf4c10e..42aa094 59080f8..6f5ebba

1:  42aa094bc9 +715 -124 4f = 1:  6f5ebba138 +715 -124 4f reject malformed unordered PSBTs

Check the values of the unordered PSBT fields: PSBT_GLOBAL_TX_UNORDERED
must be 0x03, PSBT_GLOBAL_SORT_DETERMINISTIC 0x00 or 0x01, the sort seed
at least 16 bytes long, and sort keys at most 32 bytes long.

Also reject PSBTs that break the modifiability invariants: a PSBT whose
inputs or outputs are modifiable must be unordered, since its order would
otherwise be lost, and an unordered PSBT must not have the SIGHASH_SINGLE
bit set.
@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from 6f5ebba to 925002f Compare November 16, 2026 18:18
@github-actions

Copy link
Copy Markdown
range-diff for force push 6f5ebba138 → 925002f20c November 16, 2026 18:19 UTC: 1 modified; 1 commit; base 59080f841c → a4a076085e (diverged, 6 ahead and 6 behind)

reproduce: git range-diff 59080f8..6f5ebba a4a0760..925002f

1:  6f5ebba138 +715 -124 4f ! 1:  925002f20c +715 -124 4f reject malformed unordered PSBTs
1: 6f5ebba138 ! 1: 925002f20c reject malformed unordered PSBTs
@@ crates/concurrent-psbt/src/psbt/keyed_set.rs: impl<K: Hash + Eq, V> ResultKeyedS
 +        self.entries.0.iter_mut()
 +    }
 +
-     fn add_frozen(&mut self, keys: HashSet<K>) {
-         if !self.frozen.contains(&keys) {
-             self.frozen.push(keys);
+     /// Record another operand's frozen key set, deduplicating exact matches.
+     /// This accumulates membership constraints without changing any recorded
+     /// key set. Distinct sets are retained even when one is a subset of another,
 
  ## crates/concurrent-psbt/src/psbt/tx.rs ##
 @@ crates/concurrent-psbt/src/psbt/tx.rs: use bitcoin::OutPoint;

@yuval-block
yuval-block force-pushed the enforce-concurrent-psbt-fields branch from 925002f to 86be9b9 Compare November 16, 2026 23:42
@github-actions

Copy link
Copy Markdown
range-diff for force push 925002f20c → 86be9b9b5f November 16, 2026 23:42 UTC: 1 unchanged; 1 commit; base a4a076085e → 78f9665f79 (diverged, 7 ahead and 7 behind)

reproduce: git range-diff a4a0760..925002f 78f9665..86be9b9

1:  925002f20c +715 -124 4f = 1:  86be9b9b5f +715 -124 4f reject malformed unordered PSBTs

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants