Fix consensus ordering for cross-chains

src/stl.rs

@@ -40,7 +40,7 @@ pub const LIB_ID_RGB_COMMIT: &str =
  "stl:ZMTVCU25-QDo98xR-wI91wcu-ydb7kui-QfZbF$n-0KDS2ow#tuna-safari-design";
 /// Strict types id for the library providing data types for RGB consensus.
 pub const LIB_ID_RGB_LOGIC: &str =
- "stl:bioTBozT-NqelHGE-SPbnpMA-XBNSbXZ-6X0dANE-WHVirL8#explain-marvin-bless";
+ "stl:IKFjGiNg-4MC4DKp-6XBvG0D-FCMXfqx-OnKhuRH-nb75Mcs#sector-season-anatomy";
 
 fn _rgb_commit_stl() -> Result<TypeLib, CompileError> {
  LibBuilder::new(libname!(LIB_NAME_RGB_COMMIT), tiny_bset! {

src/vm/contract.rs

@@ -23,23 +23,24 @@
 use std::borrow::Borrow;
 use std::cell::RefCell;
 use std::cmp::Ordering;
-use std::fmt::Debug;
+use std::fmt::{self, Debug, Display, Formatter};
 use std::num::NonZeroU32;
 use std::rc::Rc;
 
 use amplify::confinement;
 use amplify::num::u24;
 use bp::seals::txout::{CloseMethod, ExplicitSeal, VerifyError, Witness};
 use bp::{dbc, Tx, Txid};
+use chrono::{MappedLocalTime, TimeZone, Utc};
 use commit_verify::mpc;
 use single_use_seals::SealWitness;
 use strict_encoding::{StrictDecode, StrictDumb, StrictEncode};
 
 use crate::{
  AssetTags, AssignmentType, Assignments, AssignmentsRef, AttachState, ContractId, DataState,
  ExposedSeal, Extension, ExtensionType, FungibleState, Genesis, GlobalState, GlobalStateType,
- GraphSeal, Impossible, Inputs, Metadata, OpFullType, OpId, OpType, Operation, Transition,
- TransitionType, TxoSeal, TypedAssigns, Valencies, XChain, XOutpoint, XOutputSeal,
+ GraphSeal, Impossible, Inputs, Layer1, Metadata, OpFullType, OpId, OpType, Operation,
+ Transition, TransitionType, TxoSeal, TypedAssigns, Valencies, XChain, XOutpoint, XOutputSeal,
  LIB_NAME_RGB_LOGIC,
 };
 
@@ -290,29 +291,72 @@
  }
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Display)]
-#[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)]
+#[derive(Getters, Copy, Clone, PartialEq, Eq, Hash, Debug)]
+#[derive(StrictType, StrictEncode, StrictDecode)]
 #[strict_type(lib = LIB_NAME_RGB_LOGIC)]
 #[cfg_attr(
  feature = "serde",
  derive(Serialize, Deserialize),
  serde(crate = "serde_crate", rename_all = "camelCase")
 )]
-#[display("{height}@{timestamp}")]
 pub struct WitnessPos {
- height: u32,
+ #[getter(as_copy)]
+ layer1: Layer1,
+
+ // TODO: Move BlockHeight from bp-wallet to bp-consensus and use it here
+ #[getter(as_copy)]
+ height: NonZeroU32,
+
+ #[getter(as_copy)]
  timestamp: i64,
 }
 
+impl StrictDumb for WitnessPos {
+ fn strict_dumb() -> Self {
+ Self {
+ layer1: Layer1::Bitcoin,
+ height: NonZeroU32::MIN,
+ timestamp: 1231006505,
+ }
+ }
+}
+
+// Sat Jan 03 18:15:05 2009 UTC
+const BITCOIN_GENESIS_TIMESTAMP: i64 = 1231006505;
+
+// Sat Jan 03 18:15:05 2009 UTC
+const LIQUID_GENESIS_TIMESTAMP: i64 = 1296692202;
+
 impl WitnessPos {
- pub fn new(height: u32, timestamp: i64) -> Option<Self> {
- if height == 0 || timestamp < 1231006505 {
+ #[deprecated(
+ since = "0.11.0-beta.9",
+ note = "please use `WitnessPos::bitcoin` or `WitnessPos::liquid` instead"
+ )]
+ pub fn new(height: NonZeroU32, timestamp: i64) -> Option<Self> {
+ Self::bitcoin(height, timestamp)
+ }
+
+ pub fn bitcoin(height: NonZeroU32, timestamp: i64) -> Option<Self> {
+ if timestamp < BITCOIN_GENESIS_TIMESTAMP {
  return None;
  }
- Some(WitnessPos { height, timestamp })
+ Some(WitnessPos {
+ layer1: Layer1::Bitcoin,
+ height,
+ timestamp,
+ })
  }
 
- pub fn height(&self) -> NonZeroU32 { NonZeroU32::new(self.height).expect("invariant") }
+ pub fn liquid(height: NonZeroU32, timestamp: i64) -> Option<Self> {
+ if timestamp < LIQUID_GENESIS_TIMESTAMP {
+ return None;
+ }
+ Some(WitnessPos {
+ layer1: Layer1::Liquid,
+ height,
+ timestamp,
+ })
+ }
 }
 
 impl PartialOrd for WitnessPos {
@@ -327,7 +371,31 @@
  fn cmp(&self, other: &Self) -> Ordering {
  assert!(self.timestamp > 0);
  assert!(other.timestamp > 0);
- self.timestamp.cmp(&other.timestamp)
+ const BLOCK_TIME: i64 = 10 /*min*/ * 60 /*secs*/;
+ match (self.layer1, other.layer1) {
+ (a, b) if a == b => self.height.cmp(&other.height),
+ (Layer1::Bitcoin, Layer1::Liquid)
+ if (self.timestamp - other.timestamp).abs() < BLOCK_TIME =>
+ {
+ Ordering::Greater
+ }
+ (Layer1::Liquid, Layer1::Bitcoin)
+ if (other.timestamp - self.timestamp).abs() < BLOCK_TIME =>
+ {
+ Ordering::Less
+ }
+ _ => self.timestamp.cmp(&other.timestamp),
+ }
+ }
+}
+
+impl Display for WitnessPos {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ write!(f, "{}:{}, ", self.layer1, self.height)?;
+ match Utc.timestamp_opt(self.timestamp, 0) {
+ MappedLocalTime::Single(time) => write!(f, "{}", time.format("%Y-%m-%d %H:%M:%S")),
+ _ => f.write_str("invalid timestamp"),
+ }
  }
 }
 
@@ -672,3 +740,31 @@
  }
  }
 }
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn witness_post_timestamp() {
+ assert_eq!(WitnessPos::bitcoin(NonZeroU32::MIN, BITCOIN_GENESIS_TIMESTAMP - 1), None);
+ assert_eq!(WitnessPos::liquid(NonZeroU32::MIN, LIQUID_GENESIS_TIMESTAMP - 1), None);
+ assert_eq!(WitnessPos::liquid(NonZeroU32::MIN, BITCOIN_GENESIS_TIMESTAMP), None);
+ assert!(WitnessPos::bitcoin(NonZeroU32::MIN, BITCOIN_GENESIS_TIMESTAMP).is_some());
+ assert!(WitnessPos::liquid(NonZeroU32::MIN, LIQUID_GENESIS_TIMESTAMP).is_some());
+ assert!(WitnessPos::bitcoin(NonZeroU32::MIN, LIQUID_GENESIS_TIMESTAMP).is_some());
+ }
+
+ #[test]
+ fn witness_pos_getters() {
+ let pos = WitnessPos::bitcoin(NonZeroU32::MIN, BITCOIN_GENESIS_TIMESTAMP).unwrap();
+ assert_eq!(pos.height(), NonZeroU32::MIN);
+ assert_eq!(pos.timestamp(), BITCOIN_GENESIS_TIMESTAMP);
+ assert_eq!(pos.layer1(), Layer1::Bitcoin);
+
+ let pos = WitnessPos::liquid(NonZeroU32::MIN, LIQUID_GENESIS_TIMESTAMP).unwrap();
+ assert_eq!(pos.height(), NonZeroU32::MIN);
+ assert_eq!(pos.timestamp(), LIQUID_GENESIS_TIMESTAMP);
+ assert_eq!(pos.layer1(), Layer1::Liquid);
+ }
+}