Fix blank transition builder

std/src/interface/contract.rs

@@ -21,16 +21,17 @@
 
 use std::collections::{BTreeSet, HashSet};
 
-use amplify::confinement::{LargeOrdMap, LargeVec, SmallVec};
+use amplify::confinement::{LargeOrdMap, LargeVec, SmallVec, U16};
 use bp::Outpoint;
 use rgb::{
-    AssignmentType, AttachId, ContractId, ContractState, FungibleOutput, MediaType, RevealedAttach,
-    RevealedData, SealWitness,
+    AssignmentType, AttachId, ContractId, ContractState, DataOutput, FungibleOutput, MediaType,
+    RevealedAttach, RevealedData, SealWitness,
 };
-use strict_encoding::FieldName;
+use strict_encoding::{FieldName, StrictDeserialize};
 use strict_types::typify::TypedVal;
 use strict_types::{decode, StrictVal};
 
+use crate::interface::rgb21::Allocation;
 use crate::interface::IfaceImpl;
 
 #[derive(Clone, Eq, PartialEq, Debug, Display, Error, From)]
@@ -94,6 +95,28 @@ impl From<&FungibleOutput> for FungibleAllocation {
     }
 }
 
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct DataAllocation {
+    pub owner: Outpoint,
+    pub witness: SealWitness,
+    pub value: Allocation,
+}
+
+impl From<DataOutput> for DataAllocation {
+    fn from(out: DataOutput) -> Self { Self::from(&out) }
+}
+
+impl From<&DataOutput> for DataAllocation {
+    fn from(out: &DataOutput) -> Self {
+        DataAllocation {
+            owner: out.seal,
+            witness: out.witness,
+            value: Allocation::from_strict_serialized::<U16>(out.state.as_ref().to_owned())
+                .expect("invalid allocation data"),
+        }
+    }
+}
+
 pub trait OutpointFilter {
     fn include_outpoint(&self, outpoint: Outpoint) -> bool;
 }
@@ -182,6 +205,24 @@ impl ContractIface {
         Ok(LargeVec::try_from_iter(state).expect("same or smaller collection size"))
     }
 
+    pub fn data(
+        &self,
+        name: impl Into<FieldName>,
+    ) -> Result<LargeVec<DataAllocation>, ContractError> {
+        let name = name.into();
+        let type_id = self
+            .iface
+            .assignments_type(&name)
+            .ok_or(ContractError::FieldNameUnknown(name))?;
+        let state = self
+            .state
+            .data()
+            .iter()
+            .filter(|outp| outp.opout.ty == type_id)
+            .map(DataAllocation::from);
+        Ok(LargeVec::try_from_iter(state).expect("same or smaller collection size"))
+    }
+
     // TODO: Add rights, attachments and structured data APIs
     pub fn outpoint(
         &self,

std/src/interface/rgb21.rs

@@ -101,6 +101,9 @@ impl Allocation {
     pub fn with(index: TokenIndex, fraction: OwnedFraction) -> Allocation {
         Allocation(index, fraction)
     }
+
+    pub fn token_id(self) -> TokenIndex { self.0 }
+    pub fn fraction(self) -> OwnedFraction { self.1 }
 }
 
 impl StrictSerialize for Allocation {}

std/src/stl/specs.rs

@@ -477,8 +477,9 @@ impl DivisibleAssetSpec {
     pub fn details(&self) -> Option<&str> { self.naming.details.as_ref().map(|d| d.as_str()) }
 }
 
-#[derive(Clone, Eq, PartialEq, Debug, Default)]
-#[derive(StrictType, StrictEncode, StrictDecode)]
+#[derive(Wrapper, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, From, Debug)]
+#[wrapper(Deref, Display)]
+#[derive(StrictDumb, StrictType, StrictEncode, StrictDecode)]
 #[strict_type(lib = LIB_NAME_RGB_CONTRACT)]
 #[cfg_attr(
     feature = "serde",
@@ -498,6 +499,13 @@ impl FromStr for RicardianContract {
     }
 }
 
+impl RicardianContract {
+    pub fn from_strict_val_unchecked(value: &StrictVal) -> Self {
+        let s = value.unwrap_string();
+        RicardianContract::from_str(&s).expect("invalid term data")
+    }
+}
+
 #[derive(Wrapper, WrapperMut, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug, From)]
 #[wrapper(Deref, Display, FromStr, MathOps)]
 #[wrapper_mut(DerefMut, MathAssign)]