operation: use NonEmptyVec for TypedAssigns

Author: zoedberg

src/operation/assignments.rs

@@ -25,9 +25,9 @@ use core::fmt::Debug;
 use std::collections::{btree_map, BTreeSet};
 use std::hash::Hash;
 
-use amplify::confinement::{Confined, SmallVec, TinyOrdMap};
+use amplify::confinement::{Confined, NonEmptyVec, TinyOrdMap, U16};
 use commit_verify::{Conceal, ReservedBytes};
-use strict_encoding::{StrictDumb, StrictEncode};
+use strict_encoding::{StrictDecode, StrictDumb, StrictEncode};
 
 use super::ExposedState;
 use crate::operation::seal::GenesisSeal;
@@ -36,6 +36,34 @@ use crate::{
     SecretSeal, StateType, VoidState, LIB_NAME_RGB_COMMIT,
 };
 
+#[derive(Wrapper, WrapperMut, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, From)]
+#[wrapper(Deref)]
+#[wrapper_mut(DerefMut)]
+#[derive(StrictType, StrictDumb, StrictEncode, StrictDecode)]
+#[strict_type(lib = LIB_NAME_RGB_COMMIT, dumb = Self(NonEmptyVec::with(A::strict_dumb())))]
+#[cfg_attr(
+    feature = "serde",
+    derive(Serialize, Deserialize),
+    serde(
+        crate = "serde_crate",
+        transparent,
+        bound = "A: serde::Serialize + serde::de::DeserializeOwned"
+    )
+)]
+pub struct AssignVec<A>(NonEmptyVec<A, U16>)
+where A: StrictDumb + StrictEncode + StrictDecode;
+
+impl<A: StrictDumb + StrictEncode + StrictDecode> AssignVec<A> {
+    pub fn with(vec: NonEmptyVec<A, U16>) -> Self { Self(vec) }
+}
+
+impl<A: StrictDumb + StrictEncode + StrictDecode> IntoIterator for AssignVec<A> {
+    type Item = A;
+    type IntoIter = std::vec::IntoIter<A>;
+
+    fn into_iter(self) -> Self::IntoIter { self.0.into_iter() }
+}
+
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Display, Error)]
 #[display(doc_comments)]
 /// the requested data are not present.
@@ -231,15 +259,14 @@ impl<State: ExposedState> Assign<State, GenesisSeal> {
     )
 )]
 pub enum TypedAssigns<Seal: ExposedSeal> {
-    // TODO: Consider using non-empty variants
     #[strict_type(tag = 0x00)]
-    Declarative(SmallVec<AssignRights<Seal>>),
+    Declarative(AssignVec<AssignRights<Seal>>),
     #[strict_type(tag = 0x01)]
-    Fungible(SmallVec<AssignFungible<Seal>>),
+    Fungible(AssignVec<AssignFungible<Seal>>),
     #[strict_type(tag = 0x02)]
-    Structured(SmallVec<AssignData<Seal>>),
+    Structured(AssignVec<AssignData<Seal>>),
     #[strict_type(tag = 0xFF)]
-    Attachment(SmallVec<AssignAttach<Seal>>),
+    Attachment(AssignVec<AssignAttach<Seal>>),
 }
 
 impl<Seal: ExposedSeal> Conceal for TypedAssigns<Seal> {
@@ -248,23 +275,23 @@ impl<Seal: ExposedSeal> Conceal for TypedAssigns<Seal> {
         match self {
             TypedAssigns::Declarative(s) => {
                 let concealed_iter = s.iter().map(AssignRights::<Seal>::conceal);
-                let inner = SmallVec::try_from_iter(concealed_iter).expect("same size");
-                TypedAssigns::Declarative(inner)
+                let inner = NonEmptyVec::try_from_iter(concealed_iter).expect("same size");
+                TypedAssigns::Declarative(AssignVec::with(inner))
             }
             TypedAssigns::Fungible(s) => {
                 let concealed_iter = s.iter().map(AssignFungible::<Seal>::conceal);
-                let inner = SmallVec::try_from_iter(concealed_iter).expect("same size");
-                TypedAssigns::Fungible(inner)
+                let inner = NonEmptyVec::try_from_iter(concealed_iter).expect("same size");
+                TypedAssigns::Fungible(AssignVec::with(inner))
             }
             TypedAssigns::Structured(s) => {
                 let concealed_iter = s.iter().map(AssignData::<Seal>::conceal);
-                let inner = SmallVec::try_from_iter(concealed_iter).expect("same size");
-                TypedAssigns::Structured(inner)
+                let inner = NonEmptyVec::try_from_iter(concealed_iter).expect("same size");
+                TypedAssigns::Structured(AssignVec::with(inner))
             }
             TypedAssigns::Attachment(s) => {
                 let concealed_iter = s.iter().map(AssignAttach::<Seal>::conceal);
-                let inner = SmallVec::try_from_iter(concealed_iter).expect("same size");
-                TypedAssigns::Attachment(inner)
+                let inner = NonEmptyVec::try_from_iter(concealed_iter).expect("same size");
+                TypedAssigns::Attachment(AssignVec::with(inner))
             }
         }
     }
@@ -344,31 +371,31 @@ impl<Seal: ExposedSeal> TypedAssigns<Seal> {
     }
 
     #[inline]
-    pub fn as_declarative_mut(&mut self) -> Option<&mut SmallVec<AssignRights<Seal>>> {
+    pub fn as_declarative_mut(&mut self) -> Option<&mut NonEmptyVec<AssignRights<Seal>, U16>> {
         match self {
             TypedAssigns::Declarative(set) => Some(set),
             _ => None,
         }
     }
 
     #[inline]
-    pub fn as_fungible_mut(&mut self) -> Option<&mut SmallVec<AssignFungible<Seal>>> {
+    pub fn as_fungible_mut(&mut self) -> Option<&mut NonEmptyVec<AssignFungible<Seal>, U16>> {
         match self {
             TypedAssigns::Fungible(set) => Some(set),
             _ => None,
         }
     }
 
     #[inline]
-    pub fn as_structured_mut(&mut self) -> Option<&mut SmallVec<AssignData<Seal>>> {
+    pub fn as_structured_mut(&mut self) -> Option<&mut NonEmptyVec<AssignData<Seal>, U16>> {
         match self {
             TypedAssigns::Structured(set) => Some(set),
             _ => None,
         }
     }
 
     #[inline]
-    pub fn as_attachment_mut(&mut self) -> Option<&mut SmallVec<AssignAttach<Seal>>> {
+    pub fn as_attachment_mut(&mut self) -> Option<&mut NonEmptyVec<AssignAttach<Seal>, U16>> {
         match self {
             TypedAssigns::Attachment(set) => Some(set),
             _ => None,
@@ -446,7 +473,7 @@ impl<Seal: ExposedSeal> TypedAssigns<Seal> {
                 if index as usize >= vec.len() {
                     return Err(UnknownDataError);
                 }
-                Ok(vec.release().remove(index as usize).into_revealed_state())
+                Ok(vec.0.release().remove(index as usize).into_revealed_state())
             }
             _ => Err(UnknownDataError),
         }
@@ -458,7 +485,7 @@ impl<Seal: ExposedSeal> TypedAssigns<Seal> {
                 if index as usize >= vec.len() {
                     return Err(UnknownDataError);
                 }
-                Ok(vec.release().remove(index as usize).into_revealed_state())
+                Ok(vec.0.release().remove(index as usize).into_revealed_state())
             }
             _ => Err(UnknownDataError),
         }
@@ -468,22 +495,22 @@ impl<Seal: ExposedSeal> TypedAssigns<Seal> {
 impl TypedAssigns<GenesisSeal> {
     pub fn transmutate_seals(&self) -> TypedAssigns<GraphSeal> {
         match self {
-            TypedAssigns::Declarative(a) => TypedAssigns::Declarative(
+            TypedAssigns::Declarative(a) => TypedAssigns::Declarative(AssignVec::with(
                 Confined::try_from_iter(a.iter().map(|a| a.transmutate_seals()))
                     .expect("same size"),
-            ),
-            TypedAssigns::Fungible(a) => TypedAssigns::Fungible(
+            )),
+            TypedAssigns::Fungible(a) => TypedAssigns::Fungible(AssignVec::with(
                 Confined::try_from_iter(a.iter().map(|a| a.transmutate_seals()))
                     .expect("same size"),
-            ),
-            TypedAssigns::Structured(a) => TypedAssigns::Structured(
+            )),
+            TypedAssigns::Structured(a) => TypedAssigns::Structured(AssignVec::with(
                 Confined::try_from_iter(a.iter().map(|a| a.transmutate_seals()))
                     .expect("same size"),
-            ),
-            TypedAssigns::Attachment(a) => TypedAssigns::Attachment(
+            )),
+            TypedAssigns::Attachment(a) => TypedAssigns::Attachment(AssignVec::with(
                 Confined::try_from_iter(a.iter().map(|a| a.transmutate_seals()))
                     .expect("same size"),
-            ),
+            )),
         }
     }
 }

src/stl.rs

@@ -37,10 +37,10 @@ use crate::{
 
 /// Strict types id for the library providing data types for RGB consensus.
 pub const LIB_ID_RGB_COMMIT: &str =
-    "stl:eyIcK1Y8-vJmWKzi-CmYdpc4-bcfjuep-b0Bom0W-h6$8hJw#culture-pamela-ballad";
+    "stl:!biPP1$Y-7BZyhSV-G4WQNlq-eDiicmt-K7hBJq9-4cyQk8o#tennis-nirvana-asia";
 /// Strict types id for the library providing data types for RGB consensus.
 pub const LIB_ID_RGB_LOGIC: &str =
-    "stl:kVw2frMA-bnDO3Kj-QWS0pvy-Gak5E$$-U5QFgS7-vzikLJ4#cupid-felix-husband";
+    "stl:p0BiRWGC-gBDpjuB-$tqrAMO-hkin3Mv-NYUjn9j-!4n9p7o#miguel-motor-victor";
 
 fn _rgb_commit_stl() -> Result<TypeLib, CompileError> {
     LibBuilder::new(libname!(LIB_NAME_RGB_COMMIT), tiny_bset! {

src/validation/logic.rs

@@ -21,17 +21,19 @@
 // limitations under the License.
 
 use std::cell::RefCell;
-use std::collections::BTreeSet;
+use std::collections::btree_map::Entry;
+use std::collections::{BTreeMap, BTreeSet};
 use std::rc::Rc;
 
 use aluvm::data::Number;
 use aluvm::isa::Instr;
 use aluvm::reg::{Reg32, RegA};
 use aluvm::Vm;
-use amplify::confinement::Confined;
+use amplify::confinement::{Confined, NonEmptyVec};
 use amplify::Wrapper;
 use strict_types::TypeSystem;
 
+use crate::assignments::AssignVec;
 use crate::schema::{AssignmentsSchema, GlobalSchema};
 use crate::validation::{CheckedConsignment, ConsignmentApi};
 use crate::vm::{ContractStateAccess, ContractStateEvolve, OpInfo, OrdOpRef, RgbIsa, VmContext};
@@ -390,7 +392,7 @@ fn extract_prev_state<C: ConsignmentApi>(
     inputs: &Inputs,
     status: &mut validation::Status,
 ) -> Assignments<GraphSeal> {
-    let mut assignments = bmap! {};
+    let mut assignments: BTreeMap<AssignmentType, TypedAssigns<_>> = bmap! {};
     for input in inputs {
         let Opout { op, ty, no } = input.prev_out;
 
@@ -406,51 +408,71 @@ fn extract_prev_state<C: ConsignmentApi>(
         match prev_op.assignments_by_type(ty) {
             Some(TypedAssigns::Declarative(prev_assignments)) => {
                 if let Some(prev_assign) = prev_assignments.get(no) {
-                    if let Some(typed_assigns) = assignments
-                        .entry(ty)
-                        .or_insert_with(|| TypedAssigns::Declarative(Default::default()))
-                        .as_declarative_mut()
-                    {
-                        typed_assigns.push(prev_assign.clone()).expect("same size");
+                    match assignments.entry(ty) {
+                        Entry::Occupied(mut entry) => {
+                            if let Some(typed_assigns) = entry.get_mut().as_declarative_mut() {
+                                typed_assigns.push(prev_assign.clone()).expect("same size");
+                            }
+                        }
+                        Entry::Vacant(entry) => {
+                            entry.insert(TypedAssigns::Declarative(AssignVec::with(
+                                NonEmptyVec::with(prev_assign.clone()),
+                            )));
+                        }
                     }
                 } else {
                     status.add_failure(validation::Failure::NoPrevOut(opid, input.prev_out));
                 }
             }
             Some(TypedAssigns::Fungible(prev_assignments)) => {
                 if let Some(prev_assign) = prev_assignments.get(no) {
-                    if let Some(typed_assigns) = assignments
-                        .entry(ty)
-                        .or_insert_with(|| TypedAssigns::Fungible(Default::default()))
-                        .as_fungible_mut()
-                    {
-                        typed_assigns.push(prev_assign.clone()).expect("same size");
+                    match assignments.entry(ty) {
+                        Entry::Occupied(mut entry) => {
+                            if let Some(typed_assigns) = entry.get_mut().as_fungible_mut() {
+                                typed_assigns.push(prev_assign.clone()).expect("same size");
+                            }
+                        }
+                        Entry::Vacant(entry) => {
+                            entry.insert(TypedAssigns::Fungible(AssignVec::with(
+                                NonEmptyVec::with(prev_assign.clone()),
+                            )));
+                        }
                     }
                 } else {
                     status.add_failure(validation::Failure::NoPrevOut(opid, input.prev_out));
                 }
             }
             Some(TypedAssigns::Structured(prev_assignments)) => {
                 if let Some(prev_assign) = prev_assignments.get(no) {
-                    if let Some(typed_assigns) = assignments
-                        .entry(ty)
-                        .or_insert_with(|| TypedAssigns::Structured(Default::default()))
-                        .as_structured_mut()
-                    {
-                        typed_assigns.push(prev_assign.clone()).expect("same size");
+                    match assignments.entry(ty) {
+                        Entry::Occupied(mut entry) => {
+                            if let Some(typed_assigns) = entry.get_mut().as_structured_mut() {
+                                typed_assigns.push(prev_assign.clone()).expect("same size");
+                            }
+                        }
+                        Entry::Vacant(entry) => {
+                            entry.insert(TypedAssigns::Structured(AssignVec::with(
+                                NonEmptyVec::with(prev_assign.clone()),
+                            )));
+                        }
                     }
                 } else {
                     status.add_failure(validation::Failure::NoPrevOut(opid, input.prev_out));
                 }
             }
             Some(TypedAssigns::Attachment(prev_assignments)) => {
                 if let Some(prev_assign) = prev_assignments.get(no) {
-                    if let Some(typed_assigns) = assignments
-                        .entry(ty)
-                        .or_insert_with(|| TypedAssigns::Attachment(Default::default()))
-                        .as_attachment_mut()
-                    {
-                        typed_assigns.push(prev_assign.clone()).expect("same size");
+                    match assignments.entry(ty) {
+                        Entry::Occupied(mut entry) => {
+                            if let Some(typed_assigns) = entry.get_mut().as_attachment_mut() {
+                                typed_assigns.push(prev_assign.clone()).expect("same size");
+                            }
+                        }
+                        Entry::Vacant(entry) => {
+                            entry.insert(TypedAssigns::Attachment(AssignVec::with(
+                                NonEmptyVec::with(prev_assign.clone()),
+                            )));
+                        }
                     }
                 } else {
                     status.add_failure(validation::Failure::NoPrevOut(opid, input.prev_out));

stl/AnchoredBundle.vesper

@@ -47,7 +47,7 @@ TransitionBundle rec
       assignments map len=0..MAX8 aka=AssignmentsBlindSealTxPtr
         key is U16 aka=AssignmentType
         value union TypedAssignsBlindSealTxPtr
-          declarative list len=0..MAX16 wrapped tag=0
+          declarative list len=1..MAX16 wrapped aka=AssignVecAssignVoidStateBlindSealTxPtr tag=0
             AssignVoidStateBlindSealTxPtr union
               revealed rec tag=0
                 seal rec BlindSealTxPtr
@@ -62,7 +62,7 @@ TransitionBundle rec
                 seal bytes len=32 aka=SecretSeal
                 state is Unit aka=VoidState
                 lock bytes len=2 aka=ReservedBytes2
-          fungible list len=0..MAX16 wrapped tag=1
+          fungible list len=1..MAX16 wrapped aka=AssignVecAssignRevealedValueBlindSealTxPtr tag=1
             AssignRevealedValueBlindSealTxPtr union
               revealed rec tag=0
                 seal rec BlindSealTxPtr
@@ -81,7 +81,7 @@ TransitionBundle rec
                   value union FungibleState
                     bits64 is U64 wrapped tag=0
                 lock bytes len=2 aka=ReservedBytes2
-          structured list len=0..MAX16 wrapped tag=2
+          structured list len=1..MAX16 wrapped aka=AssignVecAssignRevealedDataBlindSealTxPtr tag=2
             AssignRevealedDataBlindSealTxPtr union
               revealed rec tag=0
                 seal rec BlindSealTxPtr
@@ -100,7 +100,7 @@ TransitionBundle rec
                   value bytes len=0..MAX16 aka=DataState
                   salt is U128
                 lock bytes len=2 aka=ReservedBytes2
-          attachment list len=0..MAX16 wrapped tag=3
+          attachment list len=1..MAX16 wrapped aka=AssignVecAssignRevealedAttachBlindSealTxPtr tag=3
             AssignRevealedAttachBlindSealTxPtr union
               revealed rec tag=0
                 seal rec BlindSealTxPtr