feat: rgb21 interface improviments

Author: crisdut

src/interface/contract.rs

@@ -22,16 +22,17 @@
 use std::collections::{BTreeSet, HashSet};
 use std::ops::Deref;
 
-use amplify::confinement::{LargeOrdMap, LargeVec, SmallVec};
+use amplify::confinement::{LargeOrdMap, LargeVec, SmallVec, U16};
 use bp::Outpoint;
 use rgb::{
-    AssetTag, AssignmentType, AttachId, BlindingFactor, ContractId, ContractState, FungibleOutput,
-    MediaType, RevealedAttach, RevealedData, WitnessId, XOutpoint, XOutputSeal,
+    AssetTag, AssignmentType, AttachId, BlindingFactor, ContractId, ContractState, DataOutput,
+    FungibleOutput, MediaType, RevealedAttach, RevealedData, WitnessId, XOutpoint, XOutputSeal,
 };
-use strict_encoding::FieldName;
+use strict_encoding::{FieldName, StrictDeserialize};
 use strict_types::typify::TypedVal;
 use strict_types::{decode, StrictVal};
 
+use super::rgb21::Allocation;
 use crate::interface::{IfaceId, IfaceImpl};
 
 #[derive(Clone, Eq, PartialEq, Debug, Display, Error, From)]
@@ -123,6 +124,28 @@ impl From<&FungibleOutput> for FungibleAllocation {
     }
 }
 
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct DataAllocation {
+    pub owner: XOutputSeal,
+    pub witness: AllocationWitness,
+    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.into(),
+            value: Allocation::from_strict_serialized::<U16>(out.state.as_ref().to_owned())
+                .expect("invalid allocation data"),
+        }
+    }
+}
+
 pub trait OutpointFilter {
     fn include_output(&self, output: impl Into<XOutpoint>) -> bool;
 }
@@ -237,6 +260,26 @@ impl ContractIface {
         Ok(LargeVec::try_from_iter(state).expect("same or smaller collection size"))
     }
 
+    pub fn data(
+        &self,
+        name: impl Into<FieldName>,
+        filter: &impl OutpointFilter,
+    ) -> 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)
+            .filter(|outp| filter.include_output(outp.seal))
+            .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,

src/interface/rgb21.rs

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