iface: refactor OutpointFilter into AssignmentsFilter

which accounts for witness id

src/interface/contract.rs

@@ -32,7 +32,7 @@ use strict_types::{StrictVal, TypeSystem};
 
 use crate::contract::{KnownState, OutputAssignment};
 use crate::info::ContractInfo;
-use crate::interface::{IfaceImpl, OutpointFilter};
+use crate::interface::{AssignmentsFilter, IfaceImpl};
 use crate::persistence::ContractStateRead;
 use crate::LIB_NAME_RGB_STD;
 
@@ -194,7 +194,21 @@ impl<S: ContractStateRead> ContractIface<S> {
         &'c self,
         state: impl IntoIterator<Item = &'c OutputAssignment<A>> + 'c,
         name: impl Into<FieldName>,
-        filter: impl OutpointFilter + 'c,
+        filter: impl AssignmentsFilter + 'c,
+    ) -> Result<impl Iterator<Item = OutputAssignment<U>> + 'c, ContractError>
+    where
+        A: Clone + KnownState + 'c,
+        U: From<A> + KnownState + 'c,
+    {
+        Ok(self
+            .extract_state_unfiltered(state, name)?
+            .filter(move |outp| filter.should_include(outp.seal, outp.witness)))
+    }
+
+    fn extract_state_unfiltered<'c, A, U>(
+        &'c self,
+        state: impl IntoIterator<Item = &'c OutputAssignment<A>> + 'c,
+        name: impl Into<FieldName>,
     ) -> Result<impl Iterator<Item = OutputAssignment<U>> + 'c, ContractError>
     where
         A: Clone + KnownState + 'c,
@@ -208,49 +222,48 @@ impl<S: ContractStateRead> ContractIface<S> {
         Ok(state
             .into_iter()
             .filter(move |outp| outp.opout.ty == type_id)
-            .filter(move |outp| filter.include_outpoint(outp.seal))
             .cloned()
             .map(OutputAssignment::<A>::transmute))
     }
 
     pub fn rights<'c>(
         &'c self,
         name: impl Into<FieldName>,
-        filter: impl OutpointFilter + 'c,
+        filter: impl AssignmentsFilter + 'c,
     ) -> Result<impl Iterator<Item = RightsAllocation> + 'c, ContractError> {
         self.extract_state(self.state.rights_all(), name, filter)
     }
 
     pub fn fungible<'c>(
         &'c self,
         name: impl Into<FieldName>,
-        filter: impl OutpointFilter + 'c,
+        filter: impl AssignmentsFilter + 'c,
     ) -> Result<impl Iterator<Item = FungibleAllocation> + 'c, ContractError> {
         self.extract_state(self.state.fungible_all(), name, filter)
     }
 
     pub fn data<'c>(
         &'c self,
         name: impl Into<FieldName>,
-        filter: impl OutpointFilter + 'c,
+        filter: impl AssignmentsFilter + 'c,
     ) -> Result<impl Iterator<Item = DataAllocation> + 'c, ContractError> {
         self.extract_state(self.state.data_all(), name, filter)
     }
 
     pub fn attachments<'c>(
         &'c self,
         name: impl Into<FieldName>,
-        filter: impl OutpointFilter + 'c,
+        filter: impl AssignmentsFilter + 'c,
     ) -> Result<impl Iterator<Item = AttachAllocation> + 'c, ContractError> {
         self.extract_state(self.state.attach_all(), name, filter)
     }
 
     pub fn allocations<'c>(
         &'c self,
-        filter: impl OutpointFilter + Copy + 'c,
+        filter: impl AssignmentsFilter + Copy + 'c,
     ) -> impl Iterator<Item = OwnedAllocation> + 'c {
         fn f<'a, S, U>(
-            filter: impl OutpointFilter + 'a,
+            filter: impl AssignmentsFilter + 'a,
             state: impl IntoIterator<Item = &'a OutputAssignment<S>> + 'a,
         ) -> impl Iterator<Item = OutputAssignment<U>> + 'a
         where
@@ -259,7 +272,7 @@ impl<S: ContractStateRead> ContractIface<S> {
         {
             state
                 .into_iter()
-                .filter(move |outp| filter.include_outpoint(outp.seal))
+                .filter(move |outp| filter.should_include(outp.seal, outp.witness))
                 .cloned()
                 .map(OutputAssignment::<S>::transmute)
         }

src/interface/filter.rs

@@ -22,88 +22,110 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::ops::Deref;
 
-use rgb::XOutpoint;
-
-pub trait OutpointFilter {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool;
+use rgb::{XOutpoint, XWitnessId};
+
+pub trait AssignmentsFilter {
+    fn should_include(
+        &self,
+        outpoint: impl Into<XOutpoint>,
+        witness_id: Option<XWitnessId>,
+    ) -> bool;
 }
 
 pub struct FilterIncludeAll;
 pub struct FilterExclude<T>(pub T);
 
-impl OutpointFilter for FilterIncludeAll {
-    fn include_outpoint(&self, _: impl Into<XOutpoint>) -> bool { true }
+impl AssignmentsFilter for FilterIncludeAll {
+    fn should_include(&self, _: impl Into<XOutpoint>, _: Option<XWitnessId>) -> bool { true }
 }
 
-impl<T: OutpointFilter> OutpointFilter for FilterExclude<T> {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool {
-        !self.0.include_outpoint(outpoint.into())
+impl<T: AssignmentsFilter> AssignmentsFilter for FilterExclude<T> {
+    fn should_include(
+        &self,
+        outpoint: impl Into<XOutpoint>,
+        witness_id: Option<XWitnessId>,
+    ) -> bool {
+        !self.0.should_include(outpoint.into(), witness_id)
     }
 }
 
-impl<T: OutpointFilter> OutpointFilter for &T {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool {
-        (*self).include_outpoint(outpoint)
+impl<T: AssignmentsFilter> AssignmentsFilter for &T {
+    fn should_include(
+        &self,
+        outpoint: impl Into<XOutpoint>,
+        witness_id: Option<XWitnessId>,
+    ) -> bool {
+        (*self).should_include(outpoint, witness_id)
     }
 }
 
-impl<T: OutpointFilter> OutpointFilter for &mut T {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool {
-        self.deref().include_outpoint(outpoint)
+impl<T: AssignmentsFilter> AssignmentsFilter for &mut T {
+    fn should_include(
+        &self,
+        outpoint: impl Into<XOutpoint>,
+        witness_id: Option<XWitnessId>,
+    ) -> bool {
+        self.deref().should_include(outpoint, witness_id)
     }
 }
 
-impl<T: OutpointFilter> OutpointFilter for Option<T> {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool {
+impl<T: AssignmentsFilter> AssignmentsFilter for Option<T> {
+    fn should_include(
+        &self,
+        outpoint: impl Into<XOutpoint>,
+        witness_id: Option<XWitnessId>,
+    ) -> bool {
         self.as_ref()
-            .map(|filter| filter.include_outpoint(outpoint))
+            .map(|filter| filter.should_include(outpoint, witness_id))
             .unwrap_or(true)
     }
 }
 
-impl OutpointFilter for XOutpoint {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool { *self == outpoint.into() }
+impl AssignmentsFilter for XOutpoint {
+    fn should_include(&self, outpoint: impl Into<XOutpoint>, _: Option<XWitnessId>) -> bool {
+        *self == outpoint.into()
+    }
 }
 
-impl<const LEN: usize> OutpointFilter for [XOutpoint; LEN] {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool {
+impl<const LEN: usize> AssignmentsFilter for [XOutpoint; LEN] {
+    fn should_include(&self, outpoint: impl Into<XOutpoint>, _: Option<XWitnessId>) -> bool {
         self.contains(&outpoint.into())
     }
 }
 
-impl OutpointFilter for &[XOutpoint] {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool {
+impl AssignmentsFilter for &[XOutpoint] {
+    fn should_include(&self, outpoint: impl Into<XOutpoint>, _: Option<XWitnessId>) -> bool {
         self.contains(&outpoint.into())
     }
 }
 
-impl OutpointFilter for Vec<XOutpoint> {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool {
+impl AssignmentsFilter for Vec<XOutpoint> {
+    fn should_include(&self, outpoint: impl Into<XOutpoint>, _: Option<XWitnessId>) -> bool {
         self.contains(&outpoint.into())
     }
 }
 
-impl OutpointFilter for HashSet<XOutpoint> {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool {
+impl AssignmentsFilter for HashSet<XOutpoint> {
+    fn should_include(&self, outpoint: impl Into<XOutpoint>, _: Option<XWitnessId>) -> bool {
         self.contains(&outpoint.into())
     }
 }
 
-impl OutpointFilter for BTreeSet<XOutpoint> {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool {
+impl AssignmentsFilter for BTreeSet<XOutpoint> {
+    fn should_include(&self, outpoint: impl Into<XOutpoint>, _: Option<XWitnessId>) -> bool {
         self.contains(&outpoint.into())
     }
 }
 
-impl<V> OutpointFilter for HashMap<XOutpoint, V> {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool {
+impl<V> AssignmentsFilter for HashMap<XOutpoint, V> {
+    fn should_include(&self, outpoint: impl Into<XOutpoint>, _: Option<XWitnessId>) -> bool {
         let outpoint = outpoint.into();
         self.keys().any(|o| *o == outpoint)
     }
 }
 
-impl<V> OutpointFilter for BTreeMap<XOutpoint, V> {
-    fn include_outpoint(&self, outpoint: impl Into<XOutpoint>) -> bool {
+impl<V> AssignmentsFilter for BTreeMap<XOutpoint, V> {
+    fn should_include(&self, outpoint: impl Into<XOutpoint>, _: Option<XWitnessId>) -> bool {
         let outpoint = outpoint.into();
         self.keys().any(|o| *o == outpoint)
     }

src/interface/mod.rs

@@ -38,7 +38,7 @@ pub use contract::{
     FungibleAllocation, OwnedAllocation, RightsAllocation, StateChange,
 };
 pub use contractum::IfaceDisplay;
-pub use filter::{FilterExclude, FilterIncludeAll, OutpointFilter};
+pub use filter::{AssignmentsFilter, FilterExclude, FilterIncludeAll};
 pub use iface::{
     ArgMap, AssignIface, ExtensionIface, GenesisIface, GlobalIface, Iface, IfaceClass, IfaceId,
     IfaceInconsistency, IfaceRef, IfaceWrapper, Modifier, OpName, OwnedIface, Req, TransitionIface,