Struct tuxedo_core::verifier::TimeLock

pub struct TimeLock {
    pub unlock_block_height: u32,
}

Allows UTXOs to be spent after a certain block height has been reached. This is useful for locking up tokens as a future investment. Timelocking also form the basis of timeout paths in swapping protocols.

This verifier is unlike many others because it requires some environmental information, namely the current block number. So there is a decision to be made:

• Allow the verifier to take come config and grab that info by calling a function given in the config. This is what we do with constraint checker.
• Modify the Verifier trait to pass along the block number.

On the one hand the block number seems like a pretty fundamental and basic thing to add. On the other hand there could be many more things to pass. For example, the timestamp. However any more complex information would require coupling with Constraint Checkers and it is not easy to red state like in accounts.

Decision: I will add block number to the signature. And remain open to adding more blockchain-level fundamental things. Especially if they are available in bitcoin script.

Regarding the verifier constraint checker separation, perhaps the right line to be drawn is that verifiers are useful in a lot of places, but perhaps not expressive enough in others. When they are not expressive enough, just use UpForGrabs and rely on the constraint checker,

Fields

unlock_block_height: u32

Trait Implementations

impl Clone for TimeLock

fn clone(&self) -> TimeLock

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TimeLock

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

Formats the value using the given formatter.

impl Decode for TimeLock

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<'de> Deserialize<'de> for TimeLock

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for TimeLock

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn>( &self, f: __CodecUsingEncodedCallback ) -> __CodecOutputReturn

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl PartialEq for TimeLock

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TypeInfo for TimeLock

type Identity = TimeLock

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl Verifier for TimeLock

type Redeemer = ()

The type that will be supplied to satisfy the verifier and redeem the UTXO.

fn verify(&self, _: &[u8], block_height: u32, _: &()) -> bool

Main function in the trait. Does the checks to make sure an output can be spent.

fn new_unspendable() -> Option<Self>

A way to create a new instance of the verifier whose semantics cannot be spent. This may be a signature check with a pubkey of 0 or a hashlock with a hash o 0 or a bitcoin script that directly returns false, etc.

impl EncodeLike for TimeLock

impl Eq for TimeLock

impl StructuralPartialEq for TimeLock