add fast-forward version codes. Closes #140

Author: dr-orlovsky

src/contract/operations.rs

@@ -36,7 +36,7 @@ use super::{GlobalState, TypedState};
 use crate::schema::{
     self, ExtensionType, OpFullType, OpType, OwnedStateType, SchemaId, TransitionType,
 };
-use crate::LIB_NAME_RGB;
+use crate::{Ffv, LIB_NAME_RGB};
 
 /// RGB contract node output pointer, defined by the node ID and output number.
 #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, Display)]
@@ -218,6 +218,7 @@ pub trait Operation: AsAny {
 #[strict_type(lib = LIB_NAME_RGB)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "serde_crate"))]
 pub struct Genesis {
+    pub ffv: Ffv,
     pub schema_id: SchemaId,
     pub chain: Chain,
     pub metadata: Option<TinyVec<u8>>,
@@ -231,6 +232,7 @@ pub struct Genesis {
 #[strict_type(lib = LIB_NAME_RGB)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "serde_crate"))]
 pub struct Extension {
+    pub ffv: Ffv,
     pub extension_type: ExtensionType,
     pub contract_id: ContractId,
     pub metadata: Option<TinyVec<u8>>,
@@ -245,6 +247,7 @@ pub struct Extension {
 #[strict_type(lib = LIB_NAME_RGB)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "serde_crate"))]
 pub struct Transition {
+    pub ffv: Ffv,
     pub transition_type: TransitionType,
     pub metadata: Option<TinyVec<u8>>,
     pub global_state: GlobalState,

src/lib.rs

@@ -66,3 +66,32 @@ pub mod prelude {
 }
 
 pub use prelude::*;
+
+/// Fast-forward version code
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Default, Debug, Display)]
+#[display("v0.10.0+{0}")]
+#[derive(StrictType, StrictEncode)]
+#[strict_type(lib = LIB_NAME_RGB)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "serde_crate"))]
+pub struct Ffv(u16);
+
+mod _ffv {
+    use strict_encoding::{DecodeError, ReadTuple, StrictDecode, TypedRead};
+
+    use crate::Ffv;
+
+    impl StrictDecode for Ffv {
+        fn strict_decode(reader: &mut impl TypedRead) -> Result<Self, DecodeError> {
+            let ffv = reader.read_tuple(|r| r.read_field().map(Self))?;
+            if ffv != Ffv::default() {
+                Err(DecodeError::DataIntegrityError(format!(
+                    "unsupported fast-forward version code belonging to a future RGB version. \
+                     Please update your software, or, if the problem persists, contact your \
+                     vendor providing the following version information: {ffv}"
+                )))
+            } else {
+                Ok(ffv)
+            }
+        }
+    }
+}

src/schema/schema.rs

@@ -21,25 +21,20 @@
 // limitations under the License.
 
 use std::cmp::Ordering;
-use std::io;
 use std::str::FromStr;
 
 use amplify::confinement::{MediumVec, TinyOrdMap, TinyOrdSet};
-use amplify::flags::FlagVec;
 use amplify::{Bytes32, RawArray};
 use baid58::{Baid58ParseError, FromBaid58, ToBaid58};
 use commit_verify::{CommitStrategy, CommitmentId};
-use strict_encoding::{
-    DecodeError, ReadTuple, StrictDecode, StrictEncode, StrictProduct, StrictTuple, StrictType,
-    TypeName, TypedRead, TypedWrite, WriteTuple,
-};
+use strict_encoding::{StrictDecode, StrictEncode, StrictType};
 use strict_types::SemId;
 
 use super::{
     ExtensionSchema, GenesisSchema, OwnedStateType, Script, StateSchema, TransitionSchema,
     ValencyType,
 };
-use crate::LIB_NAME_RGB;
+use crate::{Ffv, LIB_NAME_RGB};
 
 pub type GlobalStateType = u16;
 pub type ExtensionType = u16;
@@ -80,18 +75,7 @@ impl FromStr for SchemaId {
 #[strict_type(lib = LIB_NAME_RGB)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(crate = "serde_crate"))]
 pub struct Schema {
-    /// Feature flags control which of the available RGB features are allowed
-    /// for smart contracts created under this schema.
-    ///
-    /// NB: This is not the same as RGB protocol versioning: feature flag set
-    /// is specific to a particular RGB protocol version. The only currently
-    /// defined RGB version is RGBv1; future versions may change the whole
-    /// structure of Schema data, use of feature flags, re-define their meaning
-    /// or do other backward-incompatible changes (RGB protocol versions are
-    /// not interoperable and backward-incompatible by definitions and the
-    /// nature of client-side-validation which does not allow upgrades).
-    #[cfg_attr(feature = "serde", serde(skip))]
-    pub rgb_features: SchemaFlags,
+    pub ffv: Ffv,
     pub subset_of: Option<SchemaId>,
 
     pub global_types: TinyOrdMap<GlobalStateType, SemId>,
@@ -133,39 +117,6 @@ impl Schema {
     pub fn schema_id(&self) -> SchemaId { self.commitment_id() }
 }
 
-#[derive(Clone, Eq, PartialEq, Hash, Debug, Display, Default)]
-#[display(inner)]
-pub struct SchemaFlags(FlagVec);
-
-impl StrictType for SchemaFlags {
-    const STRICT_LIB_NAME: &'static str = LIB_NAME_RGB;
-    fn strict_name() -> Option<TypeName> { Some(tn!("SchemaFlags")) }
-}
-impl StrictProduct for SchemaFlags {}
-impl StrictTuple for SchemaFlags {
-    const FIELD_COUNT: u8 = 1;
-}
-impl StrictEncode for SchemaFlags {
-    fn strict_encode<W: TypedWrite>(&self, writer: W) -> io::Result<W> {
-        writer.write_tuple::<Self>(|w| Ok(w.write_field(&self.0.shrunk().into_inner())?.complete()))
-    }
-}
-impl StrictDecode for SchemaFlags {
-    fn strict_decode(reader: &mut impl TypedRead) -> Result<Self, DecodeError> {
-        let flags =
-            reader.read_tuple(|r| r.read_field().map(|vec| Self(FlagVec::from_inner(vec))))?;
-        if !flags.0.is_empty() {
-            Err(DecodeError::DataIntegrityError(format!(
-                "unsupported schema flags potentially belonging to a future RGB version. Please \
-                 update your software, or, if the problem persists, contact your vendor providing \
-                 the following flag information: {flags}"
-            )))
-        } else {
-            Ok(flags)
-        }
-    }
-}
-
 #[cfg(test)]
 mod test {
     use strict_encoding::StrictDumb;