Struct bpstd::Psbt

pub struct Psbt {
    pub version: PsbtVer,
    pub tx_version: TxVer,
    pub fallback_locktime: Option<LockTime>,
    pub xpubs: IndexMap<Xpub, XpubOrigin>,
    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, XpubOrigin>

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, &XpubOrigin)>

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)

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>

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 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

type Keys = GlobalKey

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

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

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Psbt

impl StructuralPartialEq for Psbt