Struct WatchtowerInput

pub struct WatchtowerInput {
    pub watchtower_idx: u16,
    pub watchtower_challenge_input_idx: u16,
    pub watchtower_challenge_utxos: Vec<CircuitTxOut>,
    pub watchtower_challenge_tx: CircuitTransaction,
    pub watchtower_challenge_witness: CircuitWitness,
    pub annex_digest: Option<[u8; 32]>,
}

Fields

watchtower_idx: u16

watchtower_challenge_input_idx: u16

watchtower_challenge_utxos: Vec<CircuitTxOut>

watchtower_challenge_tx: CircuitTransaction

watchtower_challenge_witness: CircuitWitness

annex_digest: Option<[u8; 32]>

Implementations

impl WatchtowerInput

pub fn new( watchtower_idx: u16, watchtower_challenge_input_idx: u16, watchtower_challenge_utxos: Vec<TxOut>, watchtower_challenge_tx: Transaction, watchtower_challenge_witness: Witness, annex_digest: Option<[u8; 32]>, ) -> Result<Self, &'static str>

pub fn from_txs( kickoff_tx_id: Txid, watchtower_tx: Transaction, prevout_txs: &[Transaction], watchtower_challenge_connector_start_idx: u16, ) -> Result<Self, &'static str>

Constructs a WatchtowerInput instance from the kickoff transaction, the watchtower transaction and an optional slice of previous transactions.

Arguments

• kickoff_tx_id: The kickoff transaction id whose output is consumed by an input of the watchtower transaction.

• watchtower_tx - The watchtower challenge transaction that includes an input referencing the kickoff_tx.
• prevout_txs - An optional slice of transactions, each of which should include at least one output that is later spent as an input in watchtower_tx. ( Txs should be in the same order as the inputs in the watchtower tx )

Note

All previous transactions other than kickoff tx whose outputs are spent by the watchtower_tx should be supplied in prevout_txs if they exist.

Returns

Returns Ok(WatchtowerInput) if all required data is successfully extracted and validated. Returns Err(&'static str) if any error occurs during the process.

Errors

This function will return errors if:

• The kickoff transaction is not referenced by any input in the watchtower transaction.
• The output index underflows when computing the watchtower index.
• The watchtower index exceeds MAX_NUMBER_OF_WATCHTOWERS.
• A previous transaction required to resolve an input is not provided.
• An output referenced by an input is missing or out of bounds.

Panics

Panics if:

• The watchtower index cannot be converted to u8 (should be unreachable due to earlier bounds check).

Trait Implementations

impl BorshDeserialize for WatchtowerInput

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for WatchtowerInput

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl Clone for WatchtowerInput

fn clone(&self) -> WatchtowerInput

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WatchtowerInput

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

Formats the value using the given formatter.