Struct Psbt

pub struct Psbt {
    pub version: PsbtVer,
    pub tx_version: TxVer,
    pub fallback_locktime: Option<LockTime>,
    pub xpubs: IndexMap<Xpub, XkeyOrigin>,
    pub proprietary: IndexMap<PropKey, ValueData>,
    pub unknown: IndexMap<u8, IndexMap<ByteStr, ValueData>>,
    /* private fields */
}

Fields

version: PsbtVer

PSBT version

tx_version: TxVer

Transaction version.

fallback_locktime: Option<LockTime>

Fallback locktime (used if none of the inputs specifies their locktime).

xpubs: IndexMap<Xpub, XkeyOrigin>

A global map from extended public keys to the used key fingerprint and derivation path as defined by BIP 32

proprietary: IndexMap<PropKey, ValueData>

Proprietary keys

unknown: IndexMap<u8, IndexMap<ByteStr, ValueData>>

Unknown keys

Implementations

impl Psbt

pub fn create(version: PsbtVer) -> Psbt

pub fn from_tx(tx: impl Into<UnsignedTx>) -> Psbt

pub fn to_unsigned_tx(&self) -> UnsignedTx

pub fn txid(&self) -> Txid

pub fn input(&self, index: usize) -> Option<&Input>

pub fn input_mut(&mut self, index: usize) -> Option<&mut Input>

pub fn inputs(&self) -> impl Iterator<Item = &Input>

pub fn inputs_mut(&mut self) -> impl Iterator<Item = &mut Input>

pub fn output(&self, index: usize) -> Option<&Output>

pub fn output_mut(&mut self, index: usize) -> Option<&mut Output>

pub fn outputs(&self) -> impl Iterator<Item = &Output>

pub fn outputs_mut(&mut self) -> impl Iterator<Item = &mut Output>

pub fn lock_time(&self) -> LockTime

pub fn input_sum(&self) -> Sats

pub fn output_sum(&self) -> Sats

pub fn fee(&self) -> Option<Sats>

pub fn xpubs(&self) -> impl Iterator<Item = (&Xpub, &XkeyOrigin)>

pub fn is_modifiable(&self) -> bool

pub fn are_inputs_modifiable(&self) -> bool

pub fn are_outputs_modifiable(&self) -> bool

pub fn construct_input<K, D>( &mut self, prevout: Prevout, descriptor: &D, terminal: Terminal, sequence: SeqNo, ) -> Result<&mut Input, Unmodifiable>

where D: Descriptor<K>,

pub fn construct_input_expect<K, D>( &mut self, prevout: Prevout, descriptor: &D, terminal: Terminal, sequence: SeqNo, ) -> &mut Input

where D: Descriptor<K>,

pub fn construct_output( &mut self, script_pubkey: ScriptPubkey, value: Sats, ) -> Result<&mut Output, Unmodifiable>

pub fn construct_output_expect( &mut self, script_pubkey: ScriptPubkey, value: Sats, ) -> &mut Output

pub fn construct_change<K, D>( &mut self, descriptor: &D, change_terminal: Terminal, value: Sats, ) -> Result<&mut Output, Unmodifiable>

where D: Descriptor<K>,

pub fn construct_change_expect<K, D>( &mut self, descriptor: &D, change_terminal: Terminal, value: Sats, ) -> &mut Output

where D: Descriptor<K>,

pub fn sort_outputs_by<K>( &mut self, f: impl FnMut(&Output) -> K, ) -> Result<(), Unmodifiable>

where K: Ord,

pub fn complete_construction(&mut self)

pub fn is_finalized(&self) -> bool

pub fn finalize<D, K, V>(&mut self, descriptor: &D) -> usize

where D: Descriptor<K, V>,

pub fn extract(&self) -> Result<Tx, UnfinalizedInputs>

impl Psbt

pub fn from_base64(s: &str) -> Result<Psbt, PsbtParseError>

pub fn from_base16(s: &str) -> Result<Psbt, PsbtParseError>

pub fn to_base64(&self) -> String

pub fn to_base64_ver(&self, version: PsbtVer) -> String

pub fn to_base16(&self) -> String

pub fn to_base16_ver(&self, version: PsbtVer) -> String

impl Psbt

pub fn encode( &self, ver: PsbtVer, writer: &mut dyn Write, ) -> Result<usize, IoError>

pub fn encode_vec(&self, ver: PsbtVer, writer: &mut Vec<u8>) -> usize

pub fn serialize(&self, ver: PsbtVer) -> Vec<u8>

pub fn decode(reader: &mut impl Read) -> Result<Psbt, DecodeError>

pub fn deserialize(data: impl AsRef<[u8]>) -> Result<Psbt, PsbtError>

impl Psbt

pub fn dbc_output<D>(&mut self) -> Option<&Output>

where D: DbcPsbtProof,

pub fn dbc_output_mut<D>(&mut self) -> Option<&mut Output>

where D: DbcPsbtProof,

pub fn dbc_commit<D>(&mut self) -> Result<Anchor<MerkleBlock, D>, DbcPsbtError>

where D: DbcPsbtProof,

impl Psbt

pub fn opret_hosts(&self) -> impl Iterator<Item = &Output>

pub fn opret_hosts_mut(&mut self) -> impl Iterator<Item = &mut Output>

impl Psbt

pub fn tapret_hosts(&self) -> impl Iterator<Item = &Output>

pub fn tapret_hosts_mut(&mut self) -> impl Iterator<Item = &mut Output>

impl Psbt

pub fn sign(&mut self, signer: &impl Signer) -> Result<usize, SignError>

Signs PSBT using the given signer. The signer determines whether the transaction should be accepted by the user and which script paths and keys should be used for signing for each of the inputs.

See Signer and Sign traits for details on how the interaction with signer happens.

Trait Implementations

impl Clone for Psbt

fn clone(&self) -> Psbt

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Psbt

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Psbt

fn default() -> Psbt

Returns the “default value” for a type.

impl Display for Psbt

PSBT displays Base64-encoded string. The selection of the version if the following:

• by default, it uses version specified in the PSBT itself;
• if zero {:0} is given and no width ({:0}) or a zero width ({:00}) is provided, than the PSBT is encoded as V0 even if the structure itself uses V2;
• if a width equal to one is given like in {:1}, than zero flag is ignored (so {:01} also works that way) and PSBT is encoded as V0 even if the structure itself uses V2;
• if a width equal to two is given like in {:2}, than zero flag is ignored (so {:02} also works that way) and PSBT is encoded as V2 even if the structure itself uses V1;
• all other flags has no effect on the display.

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl FromStr for Psbt

FromStr implementation parses both Base64 and Hex (Base16) encodings.

type Err = PsbtParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Psbt, <Psbt as FromStr>::Err>

Parses a string s to return a value of this type.

impl KeyMap for Psbt

const PROPRIETARY_TYPE: <Psbt as KeyMap>::Keys = GlobalKey::Proprietary

type Keys = GlobalKey

fn retrieve_key_pair<'enc>( &'enc self, version: PsbtVer, key_type: <Psbt as KeyMap>::Keys, ) -> Vec<KeyPair<<Psbt as KeyMap>::Keys, Box<dyn Encode + 'enc>, Box<dyn Encode + 'enc>>>

fn insert_singular( &mut self, key_type: <Psbt as KeyMap>::Keys, value_data: ValueData, ) -> Result<(), PsbtError>

fn insert_plural( &mut self, key_type: <Psbt as KeyMap>::Keys, key_data: ByteStr, value_data: ValueData, ) -> Result<(), PsbtError>

fn encode_map( &self, version: PsbtVer, writer: &mut dyn Write, ) -> Result<usize, IoError>

fn parse_map( &mut self, version: PsbtVer, map: Map<Self::Keys>, ) -> Result<(), PsbtError>

fn has_proprietary(&self, key: &PropKey) -> bool

fn proprietary(&self, key: &PropKey) -> Option<&ValueData>

fn proprietary_mut(&mut self, key: &PropKey) -> Option<&mut ValueData>

fn push_proprietary( &mut self, key: PropKey, value: impl Into<ValueData>, ) -> Result<(), KeyAlreadyPresent>

fn remove_proprietary(&mut self, key: &PropKey) -> Option<ValueData>

fn insert_proprietary(&mut self, prop_key: PropKey, value_data: ValueData)

fn insert_unknown( &mut self, key_type: u8, key_data: ByteStr, value_data: ValueData, )

impl LowerHex for Psbt

PSBT is formatted like hex-encoded string. The selection of the version if the following:

• by default, it uses version specified in the PSBT itself;
• if zero {:0} is given and no width ({:0}) or a zero width ({:00}) is provided, than the PSBT is encoded as V0 even if the structure itself uses V2;
• if a width equal to one is given like in {:1}, than zero flag is ignored (so {:01} also works that way) and PSBT is encoded as V0 even if the structure itself uses V2;
• if a width equal to two is given like in {:2}, than zero flag is ignored (so {:02} also works that way) and PSBT is encoded as V2 even if the structure itself uses V1;
• all other flags has no effect on the display.

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for Psbt

fn eq(&self, other: &Psbt) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RgbExt for Psbt

fn rgb_contract_ids(&self) -> Result<BTreeSet<ContractId>, FromSliceError>

fn rgb_contract_consumers( &self, contract_id: ContractId, ) -> Result<BTreeSet<(OpId, Vin)>, FromSliceError>

fn rgb_op_ids( &self, contract_id: ContractId, ) -> Result<BTreeSet<OpId>, FromSliceError>

fn rgb_transition(&self, opid: OpId) -> Result<Option<Transition>, RgbPsbtError>

fn rgb_close_method( &self, opid: OpId, ) -> Result<Option<CloseMethod>, RgbPsbtError>

fn push_rgb_transition( &mut self, transition: Transition, method: CloseMethod, ) -> Result<bool, RgbPsbtError>

fn rgb_bundles_to_mpc( &mut self, ) -> Result<Confined<BTreeMap<ContractId, BundleDichotomy>, 1, U24>, RgbPsbtError>

fn rgb_bundles( &self, ) -> Result<BTreeMap<ContractId, BundleDichotomy>, RgbPsbtError>

impl RgbPsbt for Psbt

fn rgb_embed(&mut self, batch: Batch) -> Result<(), EmbedError>

fn rgb_commit(&mut self) -> Result<Fascia, CommitError>

fn rgb_extract(&self) -> Result<Fascia, ExtractError>

impl Serialize for Psbt

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Psbt

impl StructuralPartialEq for Psbt