Struct UnsignedTx

pub struct UnsignedTx {
    pub version: TxVer,
    pub inputs: Confined<Vec<UnsignedTxIn>, 0, bc::::coding::VarIntArray::{constant#1}>,
    pub outputs: Confined<Vec<TxOut>, 0, bc::::coding::VarIntArray::{constant#1}>,
    pub lock_time: LockTime,
}

Structure representing data on unsigned transaction the way it is stored in PSBTv1 global key.

We can’t use Tx since PSBT may contain unsigned transaction with zero inputs, according to BIP-174 test cases. Tx containing zero inputs is an invalid structure, prohibited by consensus. An attempt to deserialize it will be incorrectly identified as a Segwit transaction (since zero inputs is the trick which was used to make Segwit softfork) and fail with invalid segwit flag error (since the second byte after 0 segwit indicator must be 01 and not a number of inputs) fail to parse outputs (for transactions containing just a one output).

UnsignedTx also ensures invariant that none of its inputs contain witnesses or sigscripts.

Fields

version: TxVer

inputs: Confined<Vec<UnsignedTxIn>, 0, bc::::coding::VarIntArray::{constant#1}>

outputs: Confined<Vec<TxOut>, 0, bc::::coding::VarIntArray::{constant#1}>

lock_time: LockTime

Implementations

impl UnsignedTx

pub fn with_sigs_removed(tx: Tx) -> UnsignedTx

pub fn txid(&self) -> Txid

Trait Implementations

impl Clone for UnsignedTx

fn clone(&self) -> UnsignedTx

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UnsignedTx

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

Formats the value using the given formatter.

impl Decode for UnsignedTx

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

fn deserialize(bytes: impl AsRef<[u8]>) -> Result<Self, PsbtError>

impl<'de> Deserialize<'de> for UnsignedTx

fn deserialize<__D>( __deserializer: __D, ) -> Result<UnsignedTx, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for UnsignedTx

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

impl From<Tx> for UnsignedTx

fn from(tx: Tx) -> UnsignedTx

Converts to this type from the input type.

impl Hash for UnsignedTx

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for UnsignedTx

fn eq(&self, other: &UnsignedTx) -> 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 Serialize for UnsignedTx

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 StrictDecode for UnsignedTx

fn strict_decode(reader: &mut impl TypedRead) -> Result<UnsignedTx, DecodeError>

fn strict_read(reader: impl ReadRaw) -> Result<Self, DecodeError>

impl StrictDumb for UnsignedTx

fn strict_dumb() -> UnsignedTx

impl StrictEncode for UnsignedTx

fn strict_encode<W>(&self, writer: W) -> Result<W, Error>

where W: TypedWrite,

fn strict_write(&self, writer: impl WriteRaw) -> Result<(), Error>

impl StrictStruct for UnsignedTx

const ALL_FIELDS: &'static [&'static str] = _

fn strict_check_fields()

fn strict_type_info() -> TypeInfo<Self>

impl StrictType for UnsignedTx

const STRICT_LIB_NAME: &'static str = crate::LIB_NAME_PSBT

fn strict_name() -> Option<TypeName>

impl Eq for UnsignedTx

impl StrictProduct for UnsignedTx

impl StructuralPartialEq for UnsignedTx