Skip to content

introduce Creator role - #115

Draft
yuval-block wants to merge 1 commit into
constructorfrom
creator
Draft

yuval-block wants to merge 1 commit into
constructorfrom
creator

Conversation

@yuval-block

Copy link
Copy Markdown
Collaborator

Creator initialized an empty unordered PSBT.

It wraps upstream's v2::Creator, reusing its fallback_lock_time and transaction_version setters, and omits sighash_single.

Additionally it allows setting the sort mode and, where appropriate, the sort seed.

@yuval-block
yuval-block added this pull request to stack #113 November 14, 2026 03:30
@yuval-block yuval-block linked an issue Nov 14, 2026 that may be closed by this pull request
@yuval-block yuval-block added this to the Semi-honest MVP milestone Nov 14, 2026
@github-actions

Copy link
Copy Markdown
range-diff for force push 0968a72907 → 236cb44bf8 November 14, 2026 04:13 UTC: 1 modified; 1 commit; base 199a7b165d → 0a5cb0da97 (diverged, 6 ahead and 6 behind)

reproduce: git range-diff 199a7b1..0968a72 0a5cb0d..236cb44

1:  0968a72907 +262 -2 2f ! 1:  236cb44bf8 +262 -2 2f introduce Creator role
1: 0968a72907 ! 1: 236cb44bf8 introduce Creator role
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +use crate::global::{GlobalSortExt, SortSeed};
 +use crate::input::InputSet;
 +use crate::output::OutputSet;
-+use crate::sorter::{BothModifiable, Deterministic, Explicit, Mixed, Seeded};
++use crate::sorter::{BothModifiable, DerivedOnly, ExplicitOnly, Mixed, Seeded};
 +use crate::tx::UnorderedPsbt;
 +
 +use super::constructor::Constructor;
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +///
 +/// - [`Creator::new`] selects [`Mixed`]: explicit sort keys are used where
 +///   present, and the rest are derived from the sort seed.
-+/// - [`deterministic`](Creator::deterministic) selects [`Deterministic`]:
++/// - [`derived_only`](Creator::derived_only) selects [`DerivedOnly`]:
 +///   every sort key is derived from the sort seed.
-+/// - [`explicit`](Creator::explicit) selects [`Explicit`]: every input and
++/// - [`explicit_only`](Creator::explicit_only) selects [`ExplicitOnly`]: every input and
 +///   output needs an explicit sort key.
 +///
-+/// In [`Mixed`] and [`Deterministic`] mode, `set_seed` sets
++/// In [`Mixed`] and [`DerivedOnly`] mode, `set_seed` sets
 +/// `PSBT_GLOBAL_SORT_SEED` up front and refines the mode to [`Seeded`], so a
-+/// seeded [`Deterministic`] PSBT sorts without failing.
++/// seeded [`DerivedOnly`] PSBT sorts without failing.
 +///
 +/// [`constructor`](Self::constructor) produces a [`Constructor`] with both
 +/// inputs and outputs modifiable. A PSBT cannot be a coinbase transaction,
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +#[derive(Debug, Clone, PartialEq)]
 +pub struct Creator<S = Mixed> {
 +    creator: v2::Creator,
-+    /// `PSBT_GLOBAL_SORT_DETERMINISTIC`, if set.
-+    sort_deterministic: Option<u8>,
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION`, if set.
++    sort_key_derivation: Option<u8>,
 +    seed: Option<SortSeed>,
 +    _sort: PhantomData<S>,
 +}
 +
 +impl Creator<Mixed> {
 +    /// Create a [`Creator`] in [`Mixed`] mode, leaving
-+    /// `PSBT_GLOBAL_SORT_DETERMINISTIC` unset.
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` unset.
 +    pub fn new() -> Self {
 +        Creator {
 +            creator: v2::Creator::new(),
-+            sort_deterministic: None,
++            sort_key_derivation: None,
 +            seed: None,
 +            _sort: PhantomData,
 +        }
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +        self.with_seed(seed)
 +    }
 +
-+    /// Switch to [`Deterministic`] mode (`PSBT_GLOBAL_SORT_DETERMINISTIC = 0x01`).
-+    pub fn deterministic(self) -> Creator<Deterministic> {
-+        self.with_sort_deterministic(0x01)
++    /// Switch to [`DerivedOnly`] mode (`PSBT_GLOBAL_SORT_KEY_DERIVATION = 0x01`).
++    pub fn derived_only(self) -> Creator<DerivedOnly> {
++        self.with_sort_key_derivation(0x01)
 +    }
 +
-+    /// Switch to [`Explicit`] mode (`PSBT_GLOBAL_SORT_DETERMINISTIC = 0x00`).
-+    pub fn explicit(self) -> Creator<Explicit> {
-+        self.with_sort_deterministic(0x00)
++    /// Switch to [`ExplicitOnly`] mode (`PSBT_GLOBAL_SORT_KEY_DERIVATION = 0x00`).
++    pub fn explicit_only(self) -> Creator<ExplicitOnly> {
++        self.with_sort_key_derivation(0x00)
 +    }
 +
-+    fn with_sort_deterministic<T>(mut self, mode: u8) -> Creator<T> {
-+        self.sort_deterministic = Some(mode);
++    fn with_sort_key_derivation<T>(mut self, mode: u8) -> Creator<T> {
++        self.sort_key_derivation = Some(mode);
 +        self.into_mode()
 +    }
 +}
 +
-+impl Creator<Deterministic> {
++impl Creator<DerivedOnly> {
 +    /// Set `PSBT_GLOBAL_SORT_SEED`, from which every sort key is derived.
 +    ///
 +    /// The seed may instead be set later, on the constructor or sorter.
-+    pub fn set_seed(self, seed: SortSeed) -> Creator<Seeded<Deterministic>> {
++    pub fn set_seed(self, seed: SortSeed) -> Creator<Seeded<DerivedOnly>> {
 +        self.with_seed(seed)
 +    }
 +}
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +    fn into_mode<T>(self) -> Creator<T> {
 +        Creator {
 +            creator: self.creator,
-+            sort_deterministic: self.sort_deterministic,
++            sort_key_derivation: self.sort_key_derivation,
 +            seed: self.seed,
 +            _sort: PhantomData,
 +        }
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +        let mut global = self.creator.psbt().global;
 +        global.set_unordered();
 +        global.tx_modifiable_flags = 0x03;
-+        if let Some(mode) = self.sort_deterministic {
-+            global.set_sort_deterministic(mode);
++        if let Some(mode) = self.sort_key_derivation {
++            global.set_sort_key_derivation(mode);
 +        }
 +        if let Some(seed) = self.seed {
 +            global.set_sort_seed(seed);
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +        assert_eq!(psbt.outputs, OutputSet::default());
 +
 +        let mixed = Creator::new().constructor().into_inner();
-+        assert_eq!(mixed.global.sort_deterministic(), None);
++        assert_eq!(mixed.global.sort_key_derivation(), None);
 +        assert_eq!(mixed.global.sort_seed(), None);
 +        let seeded = Creator::new()
 +            .set_seed(sort_seed.clone())
 +            .constructor()
 +            .into_inner();
-+        assert_eq!(seeded.global.sort_deterministic(), None);
++        assert_eq!(seeded.global.sort_key_derivation(), None);
 +        assert_eq!(seeded.global.sort_seed(), Some(seed.as_slice()));
 +
-+        let deterministic = Creator::new().deterministic().constructor().into_inner();
-+        assert_eq!(deterministic.global.sort_deterministic(), Some(0x01));
++        let deterministic = Creator::new().derived_only().constructor().into_inner();
++        assert_eq!(deterministic.global.sort_key_derivation(), Some(0x01));
 +        assert_eq!(deterministic.global.sort_seed(), None);
 +
-+        let explicit = Creator::new().explicit().constructor().into_inner();
-+        assert_eq!(explicit.global.sort_deterministic(), Some(0x00));
++        let explicit = Creator::new().explicit_only().constructor().into_inner();
++        assert_eq!(explicit.global.sort_key_derivation(), Some(0x00));
 +        assert_eq!(explicit.global.sort_seed(), None);
 +
 +        let output = psbt_v2::v2::Output::default();
 +        let unseeded = Creator::new()
-+            .deterministic()
++            .derived_only()
 +            .constructor()
 +            .output_with_new_uid(output.clone())
 +            .unwrap()
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +        assert!(matches!(unseeded, Err(SortError::MissingSortSeed)));
 +
 +        let ordered = Creator::new()
-+            .deterministic()
++            .derived_only()
 +            .set_seed(sort_seed.clone())
 +            .constructor()
 +            .output_with_new_uid(output.clone())
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +            .into_ordered_psbt();
 +        assert!(!ordered.global.is_unordered());
 +        assert_eq!(ordered.global.tx_modifiable_flags, 0x00);
-+        assert_eq!(ordered.global.sort_deterministic(), Some(0x01));
++        assert_eq!(ordered.global.sort_key_derivation(), Some(0x01));
 +        assert_eq!(ordered.global.sort_seed(), Some(seed.as_slice()));
 +        assert_eq!(ordered.outputs.len(), 1);
 +
 +        let timed = Creator::new()
-+            .deterministic()
++            .derived_only()
 +            .fallback_lock_time(lock_time)
 +            .transaction_version(version)
 +            .constructor()
 +            .into_inner();
 +        assert_eq!(timed.global.fallback_lock_time, Some(lock_time));
 +        assert_eq!(timed.global.tx_version, version);
-+        assert_eq!(timed.global.sort_deterministic(), Some(0x01));
++        assert_eq!(timed.global.sort_key_derivation(), Some(0x01));
 +
 +        let psbt = Creator::new()
 +            .constructor()

@github-actions

Copy link
Copy Markdown
range-diff for force push 0968a72907 → 236cb44bf8 November 14, 2026 04:13 UTC: 1 modified; 1 commit; base 199a7b165d → 0a5cb0da97 (diverged, 6 ahead and 6 behind)

reproduce: git range-diff 199a7b1..0968a72 0a5cb0d..236cb44

1:  0968a72907 +262 -2 2f ! 1:  236cb44bf8 +262 -2 2f introduce Creator role
1: 0968a72907 ! 1: 236cb44bf8 introduce Creator role
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +use crate::global::{GlobalSortExt, SortSeed};
 +use crate::input::InputSet;
 +use crate::output::OutputSet;
-+use crate::sorter::{BothModifiable, Deterministic, Explicit, Mixed, Seeded};
++use crate::sorter::{BothModifiable, DerivedOnly, ExplicitOnly, Mixed, Seeded};
 +use crate::tx::UnorderedPsbt;
 +
 +use super::constructor::Constructor;
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +///
 +/// - [`Creator::new`] selects [`Mixed`]: explicit sort keys are used where
 +///   present, and the rest are derived from the sort seed.
-+/// - [`deterministic`](Creator::deterministic) selects [`Deterministic`]:
++/// - [`derived_only`](Creator::derived_only) selects [`DerivedOnly`]:
 +///   every sort key is derived from the sort seed.
-+/// - [`explicit`](Creator::explicit) selects [`Explicit`]: every input and
++/// - [`explicit_only`](Creator::explicit_only) selects [`ExplicitOnly`]: every input and
 +///   output needs an explicit sort key.
 +///
-+/// In [`Mixed`] and [`Deterministic`] mode, `set_seed` sets
++/// In [`Mixed`] and [`DerivedOnly`] mode, `set_seed` sets
 +/// `PSBT_GLOBAL_SORT_SEED` up front and refines the mode to [`Seeded`], so a
-+/// seeded [`Deterministic`] PSBT sorts without failing.
++/// seeded [`DerivedOnly`] PSBT sorts without failing.
 +///
 +/// [`constructor`](Self::constructor) produces a [`Constructor`] with both
 +/// inputs and outputs modifiable. A PSBT cannot be a coinbase transaction,
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +#[derive(Debug, Clone, PartialEq)]
 +pub struct Creator<S = Mixed> {
 +    creator: v2::Creator,
-+    /// `PSBT_GLOBAL_SORT_DETERMINISTIC`, if set.
-+    sort_deterministic: Option<u8>,
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION`, if set.
++    sort_key_derivation: Option<u8>,
 +    seed: Option<SortSeed>,
 +    _sort: PhantomData<S>,
 +}
 +
 +impl Creator<Mixed> {
 +    /// Create a [`Creator`] in [`Mixed`] mode, leaving
-+    /// `PSBT_GLOBAL_SORT_DETERMINISTIC` unset.
++    /// `PSBT_GLOBAL_SORT_KEY_DERIVATION` unset.
 +    pub fn new() -> Self {
 +        Creator {
 +            creator: v2::Creator::new(),
-+            sort_deterministic: None,
++            sort_key_derivation: None,
 +            seed: None,
 +            _sort: PhantomData,
 +        }
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +        self.with_seed(seed)
 +    }
 +
-+    /// Switch to [`Deterministic`] mode (`PSBT_GLOBAL_SORT_DETERMINISTIC = 0x01`).
-+    pub fn deterministic(self) -> Creator<Deterministic> {
-+        self.with_sort_deterministic(0x01)
++    /// Switch to [`DerivedOnly`] mode (`PSBT_GLOBAL_SORT_KEY_DERIVATION = 0x01`).
++    pub fn derived_only(self) -> Creator<DerivedOnly> {
++        self.with_sort_key_derivation(0x01)
 +    }
 +
-+    /// Switch to [`Explicit`] mode (`PSBT_GLOBAL_SORT_DETERMINISTIC = 0x00`).
-+    pub fn explicit(self) -> Creator<Explicit> {
-+        self.with_sort_deterministic(0x00)
++    /// Switch to [`ExplicitOnly`] mode (`PSBT_GLOBAL_SORT_KEY_DERIVATION = 0x00`).
++    pub fn explicit_only(self) -> Creator<ExplicitOnly> {
++        self.with_sort_key_derivation(0x00)
 +    }
 +
-+    fn with_sort_deterministic<T>(mut self, mode: u8) -> Creator<T> {
-+        self.sort_deterministic = Some(mode);
++    fn with_sort_key_derivation<T>(mut self, mode: u8) -> Creator<T> {
++        self.sort_key_derivation = Some(mode);
 +        self.into_mode()
 +    }
 +}
 +
-+impl Creator<Deterministic> {
++impl Creator<DerivedOnly> {
 +    /// Set `PSBT_GLOBAL_SORT_SEED`, from which every sort key is derived.
 +    ///
 +    /// The seed may instead be set later, on the constructor or sorter.
-+    pub fn set_seed(self, seed: SortSeed) -> Creator<Seeded<Deterministic>> {
++    pub fn set_seed(self, seed: SortSeed) -> Creator<Seeded<DerivedOnly>> {
 +        self.with_seed(seed)
 +    }
 +}
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +    fn into_mode<T>(self) -> Creator<T> {
 +        Creator {
 +            creator: self.creator,
-+            sort_deterministic: self.sort_deterministic,
++            sort_key_derivation: self.sort_key_derivation,
 +            seed: self.seed,
 +            _sort: PhantomData,
 +        }
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +        let mut global = self.creator.psbt().global;
 +        global.set_unordered();
 +        global.tx_modifiable_flags = 0x03;
-+        if let Some(mode) = self.sort_deterministic {
-+            global.set_sort_deterministic(mode);
++        if let Some(mode) = self.sort_key_derivation {
++            global.set_sort_key_derivation(mode);
 +        }
 +        if let Some(seed) = self.seed {
 +            global.set_sort_seed(seed);
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +        assert_eq!(psbt.outputs, OutputSet::default());
 +
 +        let mixed = Creator::new().constructor().into_inner();
-+        assert_eq!(mixed.global.sort_deterministic(), None);
++        assert_eq!(mixed.global.sort_key_derivation(), None);
 +        assert_eq!(mixed.global.sort_seed(), None);
 +        let seeded = Creator::new()
 +            .set_seed(sort_seed.clone())
 +            .constructor()
 +            .into_inner();
-+        assert_eq!(seeded.global.sort_deterministic(), None);
++        assert_eq!(seeded.global.sort_key_derivation(), None);
 +        assert_eq!(seeded.global.sort_seed(), Some(seed.as_slice()));
 +
-+        let deterministic = Creator::new().deterministic().constructor().into_inner();
-+        assert_eq!(deterministic.global.sort_deterministic(), Some(0x01));
++        let deterministic = Creator::new().derived_only().constructor().into_inner();
++        assert_eq!(deterministic.global.sort_key_derivation(), Some(0x01));
 +        assert_eq!(deterministic.global.sort_seed(), None);
 +
-+        let explicit = Creator::new().explicit().constructor().into_inner();
-+        assert_eq!(explicit.global.sort_deterministic(), Some(0x00));
++        let explicit = Creator::new().explicit_only().constructor().into_inner();
++        assert_eq!(explicit.global.sort_key_derivation(), Some(0x00));
 +        assert_eq!(explicit.global.sort_seed(), None);
 +
 +        let output = psbt_v2::v2::Output::default();
 +        let unseeded = Creator::new()
-+            .deterministic()
++            .derived_only()
 +            .constructor()
 +            .output_with_new_uid(output.clone())
 +            .unwrap()
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +        assert!(matches!(unseeded, Err(SortError::MissingSortSeed)));
 +
 +        let ordered = Creator::new()
-+            .deterministic()
++            .derived_only()
 +            .set_seed(sort_seed.clone())
 +            .constructor()
 +            .output_with_new_uid(output.clone())
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +            .into_ordered_psbt();
 +        assert!(!ordered.global.is_unordered());
 +        assert_eq!(ordered.global.tx_modifiable_flags, 0x00);
-+        assert_eq!(ordered.global.sort_deterministic(), Some(0x01));
++        assert_eq!(ordered.global.sort_key_derivation(), Some(0x01));
 +        assert_eq!(ordered.global.sort_seed(), Some(seed.as_slice()));
 +        assert_eq!(ordered.outputs.len(), 1);
 +
 +        let timed = Creator::new()
-+            .deterministic()
++            .derived_only()
 +            .fallback_lock_time(lock_time)
 +            .transaction_version(version)
 +            .constructor()
 +            .into_inner();
 +        assert_eq!(timed.global.fallback_lock_time, Some(lock_time));
 +        assert_eq!(timed.global.tx_version, version);
-+        assert_eq!(timed.global.sort_deterministic(), Some(0x01));
++        assert_eq!(timed.global.sort_key_derivation(), Some(0x01));
 +
 +        let psbt = Creator::new()
 +            .constructor()

@github-actions

Copy link
Copy Markdown
range-diff for force push 236cb44bf8 → 0e0da0d73a November 14, 2026 04:23 UTC: 1 unchanged; 1 commit; base 0a5cb0da97 → eaf668d595 (diverged, 3 ahead and 3 behind)

reproduce: git range-diff 0a5cb0d..236cb44 eaf668d..0e0da0d

1:  236cb44bf8 +262 -2 2f = 1:  0e0da0d73a +262 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push 236cb44bf8 → 0e0da0d73a November 14, 2026 04:30 UTC: 1 unchanged; 1 commit; base 0a5cb0da97 → eaf668d595 (diverged, 3 ahead and 3 behind)

reproduce: git range-diff 0a5cb0d..236cb44 eaf668d..0e0da0d

1:  236cb44bf8 +262 -2 2f = 1:  0e0da0d73a +262 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push 0e0da0d73a → d84d44be81 November 14, 2026 05:21 UTC: 1 unchanged; 1 commit; base eaf668d595 → 2badec25e6 (diverged, 3 ahead and 3 behind)

reproduce: git range-diff eaf668d..0e0da0d 2badec2..d84d44b

1:  0e0da0d73a +262 -2 2f = 1:  d84d44be81 +262 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push 0e0da0d73a → d84d44be81 November 14, 2026 05:30 UTC: 1 unchanged; 1 commit; base eaf668d595 → 2badec25e6 (diverged, 3 ahead and 3 behind)

reproduce: git range-diff eaf668d..0e0da0d 2badec2..d84d44b

1:  0e0da0d73a +262 -2 2f = 1:  d84d44be81 +262 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push d84d44be81 → aa2ca9127b November 14, 2026 08:26 UTC: 1 modified; 1 commit; base 2badec25e6 → 06a6e9a687 (diverged, 11 ahead and 9 behind)

reproduce: git range-diff 2badec2..d84d44b 06a6e9a..aa2ca91

1:  d84d44be81 +262 -2 2f ! 1:  aa2ca9127b +266 -2 2f introduce Creator role
1: d84d44be81 ! 1: aa2ca9127b introduce Creator role
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +use bitcoin::transaction;
 +use psbt_v2::v2;
 +
-+use crate::global::{GlobalSortExt, SortSeed};
++use crate::global::{Global, GlobalSortExt, SortSeed};
 +use crate::input::InputSet;
 +use crate::output::OutputSet;
 +use crate::sorter::{BothModifiable, DerivedOnly, ExplicitOnly, Mixed, Seeded};
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +    /// Build a [`Constructor`] with both inputs and outputs modifiable
 +    /// (`tx_modifiable_flags = 0x03`).
 +    pub fn constructor(self) -> Constructor<BothModifiable, S> {
-+        let mut global = self.creator.psbt().global;
++        let mut global = Global::from(self.creator.psbt().global);
 +        global.set_unordered();
 +        global.tx_modifiable_flags = 0x03;
 +        if let Some(mode) = self.sort_key_derivation {
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +mod tests {
 +    use super::*;
 +    use crate::global::GlobalSortExt;
-+    use crate::output::OutputUniqueIdExt;
 +    use crate::sorter::SortError;
++    use bitcoin::{Amount, ScriptBuf};
 +
 +    fn exercise_creator(seed: Vec<u8>, lock_time: u32, version: i32) {
 +        let sort_seed = SortSeed::try_from(seed.clone()).expect("test seeds are at least 16 bytes");
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +        assert_eq!(explicit.global.sort_key_derivation(), Some(0x00));
 +        assert_eq!(explicit.global.sort_seed(), None);
 +
-+        let output = psbt_v2::v2::Output::default();
 +        let unseeded = Creator::new()
 +            .derived_only()
 +            .constructor()
-+            .output_with_new_uid(output.clone())
++            .output_with_new_uid(Amount::ZERO, ScriptBuf::new())
 +            .unwrap()
 +            .no_more_inputs()
 +            .no_more_outputs()
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +            .derived_only()
 +            .set_seed(sort_seed.clone())
 +            .constructor()
-+            .output_with_new_uid(output.clone())
++            .output_with_new_uid(Amount::ZERO, ScriptBuf::new())
 +            .unwrap()
 +            .no_more_inputs()
 +            .no_more_outputs()
 +            .into_ordered_psbt();
-+        assert!(!ordered.global.is_unordered());
++        let ordered_global = Global::from(ordered.global.clone());
++        assert!(!ordered_global.is_unordered());
 +        assert_eq!(ordered.global.tx_modifiable_flags, 0x00);
-+        assert_eq!(ordered.global.sort_key_derivation(), Some(0x01));
-+        assert_eq!(ordered.global.sort_seed(), Some(seed.as_slice()));
++        assert_eq!(ordered_global.sort_key_derivation(), Some(0x01));
++        assert_eq!(ordered_global.sort_seed(), Some(seed.as_slice()));
 +        assert_eq!(ordered.outputs.len(), 1);
 +
 +        let timed = Creator::new()
@@ crates/concurrent-psbt/src/roles/creator.rs (new)
 +
 +        let psbt = Creator::new()
 +            .constructor()
-+            .output_with_new_uid(output.clone())
++            .output_with_new_uid(Amount::ZERO, ScriptBuf::new())
 +            .unwrap()
-+            .output_with_new_uid(output)
++            .output_with_new_uid(Amount::ZERO, ScriptBuf::new())
 +            .unwrap()
 +            .try_into_psbt()
 +            .expect("outputs carry no lock time requirements");
-+        assert!(psbt.global.is_unordered());
-+        let first = psbt.outputs[0].unique_id().expect("Creator stamps an ID");
-+        let second = psbt.outputs[1].unique_id().expect("Creator stamps an ID");
++        assert!(Global::from(psbt.global.clone()).is_unordered());
++        let [first, second] = [0, 1].map(|i| {
++            crate::output::Output::try_from(psbt.outputs[i].clone())
++                .expect("Creator stamps an ID")
++                .unique_id()
++                .clone()
++        });
 +        assert_ne!(first, second);
 +    }
 +

@github-actions

Copy link
Copy Markdown
range-diff for force push 5278ebb81f → a703e5afed November 14, 2026 09:04 UTC: 1 unchanged; 1 commit; base 533330d9a2 → e3bd458414 (diverged, 12 ahead and 12 behind)

reproduce: git range-diff 533330d..5278ebb e3bd458..a703e5a

1:  5278ebb81f +283 -2 2f = 1:  a703e5afed +283 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push a703e5afed → 8b9d9c2a82 November 14, 2026 11:02 UTC: 1 unchanged; 1 commit; base e3bd458414 → b051add4bc (diverged, 14 ahead and 13 behind)

reproduce: git range-diff e3bd458..a703e5a b051add..8b9d9c2

1:  a703e5afed +283 -2 2f = 1:  8b9d9c2a82 +283 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push a703e5afed → 8b9d9c2a82 November 14, 2026 11:02 UTC: 1 unchanged; 1 commit; base e3bd458414 → b051add4bc (diverged, 14 ahead and 13 behind)

reproduce: git range-diff e3bd458..a703e5a b051add..8b9d9c2

1:  a703e5afed +283 -2 2f = 1:  8b9d9c2a82 +283 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push ac52289417 → 3d413230fb November 15, 2026 02:13 UTC: 1 unchanged; 1 commit; base e3e0e7e02c → bb9dfa0fd7 (diverged, 14 ahead and 14 behind)

reproduce: git range-diff e3e0e7e..ac52289 bb9dfa0..3d41323

1:  ac52289417 +321 -2 2f = 1:  3d413230fb +321 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push ac52289417 → 3d413230fb November 15, 2026 02:14 UTC: 1 unchanged; 1 commit; base e3e0e7e02c → bb9dfa0fd7 (diverged, 14 ahead and 14 behind)

reproduce: git range-diff e3e0e7e..ac52289 bb9dfa0..3d41323

1:  ac52289417 +321 -2 2f = 1:  3d413230fb +321 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push 3d413230fb → f330b6a12f November 15, 2026 12:51 UTC: 1 unchanged; 1 commit; base bb9dfa0fd7 → 04dc575e48 (diverged, 3 ahead and 3 behind)

reproduce: git range-diff bb9dfa0..3d41323 04dc575..f330b6a

1:  3d413230fb +321 -2 2f = 1:  f330b6a12f +321 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push 3d413230fb → f330b6a12f November 15, 2026 12:51 UTC: 1 unchanged; 1 commit; base bb9dfa0fd7 → 04dc575e48 (diverged, 3 ahead and 3 behind)

reproduce: git range-diff bb9dfa0..3d41323 04dc575..f330b6a

1:  3d413230fb +321 -2 2f = 1:  f330b6a12f +321 -2 2f introduce Creator role

@github-code-quality

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

Copy link
Copy Markdown

Code coverage overview

Languages: Rust

Rust / code-coverage/cargo-llvm-cov

constructor 5f4ab3b creator a5b62c8 +/-
100% 100% 0%
View coverage of the 10 most impacted files.
File constructor 5f4ab3b creator a5b62c8 +/-
crates/concurre.../src/psbt/tx.rs 0% 100% +100%
crates/concurre...bt/keyed_set.rs 0% 100% +100%
crates/concurre...s/sorter/mod.rs 0% 100% +100%
crates/concurre...structor/mod.rs 0% 100% +100%
crates/concurre.../psbt/global.rs 0% 100% +100%
crates/concurre...bt/input_set.rs 0% 100% +100%
crates/concurre...oles/creator.rs 0% 100% +100%
crates/concurre...t/output_set.rs 0% 100% +100%
crates/concurre...sorter/error.rs 0% 100% +100%
crates/concurre...s/sorter/key.rs 0% 100% +100%

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


Updated November 16, 2026 23:45 UTC

@github-actions

Copy link
Copy Markdown
range-diff for force push f330b6a12f → ea78d3fd3c November 15, 2026 23:52 UTC: 1 unchanged; 1 commit; base 04dc575e48 → 638d7d0739 (diverged, 14 ahead and 14 behind)

reproduce: git range-diff 04dc575..f330b6a 638d7d0..ea78d3f

1:  f330b6a12f +321 -2 2f = 1:  ea78d3fd3c +321 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push ea78d3fd3c → d41b04f068 November 16, 2026 00:17 UTC: 1 unchanged; 1 commit; base 638d7d0739 → 7c329c3e9a (diverged, 11 ahead and 11 behind)

reproduce: git range-diff 638d7d0..ea78d3f 7c329c3..d41b04f

1:  ea78d3fd3c +321 -2 2f = 1:  d41b04f068 +321 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push ea78d3fd3c → d41b04f068 November 16, 2026 00:22 UTC: 1 unchanged; 1 commit; base 638d7d0739 → 7c329c3e9a (diverged, 11 ahead and 11 behind)

reproduce: git range-diff 638d7d0..ea78d3f 7c329c3..d41b04f

1:  ea78d3fd3c +321 -2 2f = 1:  d41b04f068 +321 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push d41b04f068 → 08b4b8fdbf November 16, 2026 03:26 UTC: 1 unchanged; 1 commit; base 7c329c3e9a → ce5df60a15 (diverged, 14 ahead and 14 behind)

reproduce: git range-diff 7c329c3..d41b04f ce5df60..08b4b8f

1:  d41b04f068 +321 -2 2f = 1:  08b4b8fdbf +321 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push 08b4b8fdbf → 3febc3f0ab November 16, 2026 04:46 UTC: 1 unchanged; 1 commit; base ce5df60a15 → 99254980d7 (diverged, 14 ahead and 14 behind)

reproduce: git range-diff ce5df60..08b4b8f 9925498..3febc3f

1:  08b4b8fdbf +321 -2 2f = 1:  3febc3f0ab +321 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push 3febc3f0ab → f2148b34d6 November 16, 2026 06:07 UTC: 1 unchanged; 1 commit; base 99254980d7 → adbd771ae0 (diverged, 14 ahead and 14 behind)

reproduce: git range-diff 9925498..3febc3f adbd771..f2148b3

1:  3febc3f0ab +321 -2 2f = 1:  f2148b34d6 +321 -2 2f introduce Creator role

Creator initialized an empty unordered PSBT.

It wraps upstream's v2::Creator, reusing its fallback_lock_time and
transaction_version setters, and omits sighash_single.

Additionally it allows setting the sort mode and, where appropriate, the
sort seed.
@github-actions

Copy link
Copy Markdown
range-diff for force push f2148b34d6 → ad38b7ff84 November 16, 2026 18:21 UTC: 1 unchanged; 1 commit; base adbd771ae0 → dfb127c290 (diverged, 10 ahead and 10 behind)

reproduce: git range-diff adbd771..f2148b3 dfb127c..ad38b7f

1:  f2148b34d6 +321 -2 2f = 1:  ad38b7ff84 +321 -2 2f introduce Creator role

@github-actions

Copy link
Copy Markdown
range-diff for force push ad38b7ff84 → a5b62c8b49 November 16, 2026 23:44 UTC: 1 unchanged; 1 commit; base dfb127c290 → 4407fe788c (diverged, 11 ahead and 11 behind)

reproduce: git range-diff dfb127c..ad38b7f 4407fe7..a5b62c8

1:  ad38b7ff84 +321 -2 2f = 1:  a5b62c8b49 +321 -2 2f introduce Creator role

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.

concurrent PSBT Roles

2 participants