Enum LockTime

pub enum LockTime {
    Blocks(Height),
    Time(Time),
}

A relative lock time value, representing either a block height or time (512 second intervals).

The relative::LockTime type does not have any constructors, this is by design, please use Sequence::to_relative_lock_time to create a relative lock time.

Relevant BIPs

• BIP 68 Relative lock-time using consensus-enforced sequence numbers
• BIP 112 CHECKSEQUENCEVERIFY

Variants

Blocks(Height)

A block height lock time value.

Time(Time)

A 512 second time interval value.

Implementations

impl LockTime

pub fn is_satisfied_by(&self, h: Height, t: Time) -> bool

Returns true if this [relative::LockTime] is satisfied by either height or time.

Examples

// Users that have chain data can get the current height and time to check against a lock.
let height_and_time = (current_time(), current_height());  // tuple order does not matter.
assert!(lock.is_satisfied_by(current_height(), current_time()));

pub fn is_implied_by(&self, other: LockTime) -> bool

Returns true if satisfaction of other lock time implies satisfaction of this [relative::LockTime].

A lock time can only be satisfied by n blocks being mined or n seconds passing. If you have two lock times (same unit) then the larger lock time being satisfied implies (in a mathematical sense) the smaller one being satisfied.

This function is useful when checking sequence values against a lock, first one checks the sequence represents a relative lock time by converting to LockTime then use this function to see if satisfaction of the newly created lock time would imply satisfaction of self.

Can also be used to remove the smaller value of two OP_CHECKSEQUENCEVERIFY operations within one branch of the script.

Examples

let satisfied = match test_sequence.to_relative_lock_time() {
    None => false, // Handle non-lock-time case.
    Some(test_lock) => lock.is_implied_by(test_lock),
};
assert!(satisfied);

pub fn is_satisfied_by_height(&self, h: Height) -> Result<bool, Error>

Returns true if this [relative::LockTime] is satisfied by Height.

Errors

Returns an error if this lock is not lock-by-height.

Examples

let height: u16 = 100;
let lock = Sequence::from_height(height).to_relative_lock_time().expect("valid height");
assert!(lock.is_satisfied_by_height(Height::from(height+1)).expect("a height"));

pub fn is_satisfied_by_time(&self, t: Time) -> Result<bool, Error>

Returns true if this [relative::LockTime] is satisfied by Time.

Errors

Returns an error if this lock is not lock-by-time.

Examples

let intervals: u16 = 70; // approx 10 hours;
let lock = Sequence::from_512_second_intervals(intervals).to_relative_lock_time().expect("valid time");
assert!(lock.is_satisfied_by_time(Time::from_512_second_intervals(intervals + 10)).expect("a time"));

Trait Implementations

impl Clone for LockTime

fn clone(&self) -> LockTime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LockTime

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LockTime

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LockTime

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

Formats the value using the given formatter.

impl From<Height> for LockTime

fn from(h: Height) -> LockTime

Converts to this type from the input type.

impl From<Time> for LockTime

fn from(t: Time) -> LockTime

Converts to this type from the input type.

impl Hash for LockTime

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 LockTime

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

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 Copy for LockTime

impl Eq for LockTime

impl StructuralPartialEq for LockTime