iface: remove code duplication for history methods

src/interface/contract.rs

@@ -21,6 +21,7 @@
 
 use std::borrow::Borrow;
 use std::collections::{BTreeSet, HashMap, HashSet};
+use std::iter;
 
 use invoice::{Allocation, Amount};
 use rgb::{
@@ -97,6 +98,27 @@ pub enum ContractOp {
  Attach(NonFungibleOp<AttachState>),
 }
 
+// nobody knows what this strange warning by rustc compiler means
+#[allow(opaque_hidden_inferred_bound)]
+pub trait ContractOperation {
+ type State: KnownState;
+
+ fn new_genesis(
+ our_allocations: HashSet<OutputAssignment<Self::State>>,
+ ) -> impl ExactSizeIterator<Item = Self>;
+
+ fn new_sent(
+ witness: WitnessInfo,
+ ext_allocations: HashSet<OutputAssignment<Self::State>>,
+ _: HashSet<OutputAssignment<Self::State>>,
+ ) -> impl ExactSizeIterator<Item = Self>;
+
+ fn new_received(
+ witness: WitnessInfo,
+ our_allocations: HashSet<OutputAssignment<Self::State>>,
+ ) -> impl ExactSizeIterator<Item = Self>;
+}
+
 #[derive(Clone, Eq, PartialEq, Hash, Debug)]
 #[cfg_attr(
  feature = "serde",
@@ -122,7 +144,9 @@ pub enum NonFungibleOp<S: KnownState> {
  },
 }
 
-impl<S: KnownState> NonFungibleOp<S> {
+impl<S: KnownState> ContractOperation for NonFungibleOp<S> {
+ type State = S;
+
  fn new_genesis(
  our_allocations: HashSet<OutputAssignment<S>>,
  ) -> impl ExactSizeIterator<Item = Self> {
@@ -135,6 +159,7 @@ impl<S: KnownState> NonFungibleOp<S> {
  fn new_sent(
  witness: WitnessInfo,
  ext_allocations: HashSet<OutputAssignment<S>>,
+ _: HashSet<OutputAssignment<S>>,
  ) -> impl ExactSizeIterator<Item = Self> {
  ext_allocations.into_iter().map(move |a| Self::Sent {
  opid: a.opout.op,
@@ -182,43 +207,47 @@ pub enum FungibleOp {
  },
 }
 
-impl FungibleOp {
- fn new_genesis(our_allocations: &HashSet<OutputAssignment<Amount>>) -> Self {
+impl ContractOperation for FungibleOp {
+ type State = Amount;
+
+ fn new_genesis(
+ our_allocations: HashSet<OutputAssignment<Amount>>,
+ ) -> impl ExactSizeIterator<Item = Self> {
  let to = our_allocations.iter().map(|a| a.seal).collect();
- let issued = our_allocations.iter().map(|a| a.state.clone()).sum();
- Self::Genesis { issued, to }
+ let issued = our_allocations.iter().map(|a| a.state).sum();
+ iter::once(Self::Genesis { issued, to })
  }
 
  fn new_sent(
  witness: WitnessInfo,
- ext_allocations: &HashSet<OutputAssignment<Amount>>,
- our_allocations: &HashSet<OutputAssignment<Amount>>,
- ) -> Self {
+ ext_allocations: HashSet<OutputAssignment<Amount>>,
+ our_allocations: HashSet<OutputAssignment<Amount>>,
+ ) -> impl ExactSizeIterator<Item = Self> {
  let opids = our_allocations.iter().map(|a| a.opout.op).collect();
  let to = ext_allocations.iter().map(|a| a.seal).collect();
  let mut amount = ext_allocations.iter().map(|a| a.state.clone()).sum();
- amount -= our_allocations.iter().map(|a| a.state.clone()).sum();
- Self::Sent {
+ amount -= our_allocations.iter().map(|a| a.state).sum();
+ iter::once(Self::Sent {
  opids,
  amount,
  to,
  witness,
- }
+ })
  }
 
  fn new_received(
  witness: WitnessInfo,
- our_allocations: &HashSet<OutputAssignment<Amount>>,
- ) -> Self {
+ our_allocations: HashSet<OutputAssignment<Amount>>,
+ ) -> impl ExactSizeIterator<Item = Self> {
  let opids = our_allocations.iter().map(|a| a.opout.op).collect();
  let to = our_allocations.iter().map(|a| a.seal).collect();
- let amount = our_allocations.iter().map(|a| a.state.clone()).sum();
- Self::Received {
+ let amount = our_allocations.iter().map(|a| a.state).sum();
+ iter::once(Self::Received {
  opids,
  amount,
  to,
  witness,
- }
+ })
  }
 }
 
@@ -394,30 +423,39 @@ impl<S: ContractStateRead> ContractIface<S> {
  .collect())
  }
 
- pub fn history_fungible(
- &self,
+ fn operations<
+ 'c,
+ Op: ContractOperation,
+ T: KnownState + 'c,
+ I: Iterator<Item = &'c OutputAssignment<T>>,
+ >(
+ &'c self,
+ state: impl Fn(&'c S) -> I,
  filter_outpoints: impl AssignmentsFilter,
  filter_witnesses: impl AssignmentsFilter,
- ) -> Result<Vec<FungibleOp>, ContractError> {
+ ) -> Result<Vec<Op>, ContractError>
+ where
+ Op::State: From<T>,
+ {
  // get all allocations which ever belonged to this wallet and store them by witness id
- let allocations_our_outpoint = self
- .state
- .fungible_all()
+ let mut allocations_our_outpoint = state(&self.state)
  .filter(move |outp| filter_outpoints.should_include(outp.seal, outp.witness))
  .fold(HashMap::<_, HashSet<_>>::new(), |mut map, a| {
- map.entry(a.witness).or_default().insert(a.transmute());
+ map.entry(a.witness)
+ .or_default()
+ .insert(a.clone().transmute());
  map
  });
  // get all allocations which has a witness transaction belonging to this wallet
- let allocations_our_witness = self
- .state
- .fungible_all()
+ let mut allocations_our_witness = state(&self.state)
  .filter(move |outp| filter_witnesses.should_include(outp.seal, outp.witness))
  .fold(HashMap::<_, HashSet<_>>::new(), |mut map, a| {
  let witness = a.witness.expect(
  "all empty witnesses must be already filtered out by wallet.filter_witness()",
  );
- map.entry(witness).or_default().insert(a.transmute());
+ map.entry(witness)
+ .or_default()
+ .insert(a.clone().transmute());
  map
  });
 
@@ -431,149 +469,75 @@ impl<S: ContractStateRead> ContractIface<S> {
  // reconstruct contract history from the wallet perspective
  let mut ops = Vec::with_capacity(witness_ids.len() + 1);
  // add allocations with no witness to the beginning of the history
- if let Some(genesis_allocations) = allocations_our_outpoint.get(&None) {
- ops.push(FungibleOp::new_genesis(genesis_allocations));
+ if let Some(genesis_allocations) = allocations_our_outpoint.remove(&None) {
+ ops.extend(Op::new_genesis(genesis_allocations));
  }
  for witness_id in witness_ids {
- let our_outpoint = allocations_our_outpoint.get(&Some(witness_id));
- let our_witness = allocations_our_witness.get(&witness_id);
+ let our_outpoint = allocations_our_outpoint.remove(&Some(witness_id));
+ let our_witness = allocations_our_witness.remove(&witness_id);
  let witness_info = self.witness_info(witness_id).expect(
  "witness id was returned from the contract state above, so it must be there",
  );
- let op = match (our_outpoint, our_witness) {
+ match (our_outpoint, our_witness) {
  // we own both allocation and witness transaction: these allocations are changes and
  // outgoing payments. The difference between the change and the payments are whether
  // a specific allocation is listed in the first tuple pattern field.
  (Some(our_allocations), Some(all_allocations)) => {
  // all_allocations - our_allocations = external payments
- let ext_allocations = all_allocations.difference(our_allocations);
- FungibleOp::new_sent(
+ let ext_allocations = all_allocations.difference(&our_allocations);
+ ops.extend(Op::new_sent(
  witness_info,
- &ext_allocations.copied().collect(),
+ ext_allocations.cloned().collect(),
  our_allocations,
- )
+ ))
  }
  // the same as above, but the payment has no change
  (None, Some(ext_allocations)) => {
- FungibleOp::new_sent(witness_info, ext_allocations, &set![])
+ ops.extend(Op::new_sent(witness_info, ext_allocations, set![]))
  }
  // we own allocation but the witness transaction was made by other wallet:
  // this is an incoming payment to us.
  (Some(our_allocations), None) => {
- FungibleOp::new_received(witness_info, our_allocations)
+ ops.extend(Op::new_received(witness_info, our_allocations))
  }
  // these can't get into the `witness_ids` due to the used filters
  (None, None) => unreachable!("broken allocation filters"),
  };
- ops.push(op);
  }
 
  Ok(ops)
  }
 
+ pub fn history_fungible(
+ &self,
+ filter_outpoints: impl AssignmentsFilter,
+ filter_witnesses: impl AssignmentsFilter,
+ ) -> Result<Vec<FungibleOp>, ContractError> {
+ self.operations(|state| state.fungible_all(), filter_outpoints, filter_witnesses)
+ }
+
  pub fn history_rights(
  &self,
  filter_outpoints: impl AssignmentsFilter,
  filter_witnesses: impl AssignmentsFilter,
  ) -> Result<Vec<NonFungibleOp<VoidState>>, ContractError> {
- self.history_non_fungible(|state| state.rights_all(), filter_outpoints, filter_witnesses)
+ self.operations(|state| state.rights_all(), filter_outpoints, filter_witnesses)
  }
 
  pub fn history_data(
  &self,
  filter_outpoints: impl AssignmentsFilter,
  filter_witnesses: impl AssignmentsFilter,
  ) -> Result<Vec<NonFungibleOp<DataState>>, ContractError> {
- self.history_non_fungible(|state| state.data_all(), filter_outpoints, filter_witnesses)
+ self.operations(|state| state.data_all(), filter_outpoints, filter_witnesses)
  }
 
  pub fn history_attach(
  &self,
  filter_outpoints: impl AssignmentsFilter,
  filter_witnesses: impl AssignmentsFilter,
  ) -> Result<Vec<NonFungibleOp<AttachState>>, ContractError> {
- self.history_non_fungible(|state| state.attach_all(), filter_outpoints, filter_witnesses)
- }
-
- fn history_non_fungible<
- 'c,
- State: KnownState + From<T>,
- T: KnownState + 'c,
- I: Iterator<Item = &'c OutputAssignment<T>>,
- >(
- &'c self,
- state: impl Fn(&'c S) -> I,
- filter_outpoints: impl AssignmentsFilter,
- filter_witnesses: impl AssignmentsFilter,
- ) -> Result<Vec<NonFungibleOp<State>>, ContractError> {
- // get all allocations which ever belonged to this wallet and store them by witness id
- let mut allocations_our_outpoint = state(&self.state)
- .filter(move |outp| filter_outpoints.should_include(outp.seal, outp.witness))
- .fold(HashMap::<_, HashSet<_>>::new(), |mut map, a| {
- map.entry(a.witness)
- .or_default()
- .insert(a.clone().transmute());
- map
- });
- // get all allocations which has a witness transaction belonging to this wallet
- let mut allocations_our_witness = state(&self.state)
- .filter(move |outp| filter_witnesses.should_include(outp.seal, outp.witness))
- .fold(HashMap::<_, HashSet<_>>::new(), |mut map, a| {
- let witness = a.witness.expect(
- "all empty witnesses must be already filtered out by wallet.filter_witness()",
- );
- map.entry(witness)
- .or_default()
- .insert(a.clone().transmute());
- map
- });
-
- // gather all witnesses from both sets
- let mut witness_ids = allocations_our_witness
- .keys()
- .cloned()
- .collect::<BTreeSet<_>>();
- witness_ids.extend(allocations_our_outpoint.keys().filter_map(|x| *x));
-
- // reconstruct contract history from the wallet perspective
- let mut ops = Vec::with_capacity(witness_ids.len() + 1);
- // add allocations with no witness to the beginning of the history
- if let Some(genesis_allocations) = allocations_our_outpoint.remove(&None) {
- ops.extend(NonFungibleOp::new_genesis(genesis_allocations));
- }
- for witness_id in witness_ids {
- let our_outpoint = allocations_our_outpoint.remove(&Some(witness_id));
- let our_witness = allocations_our_witness.remove(&witness_id);
- let witness_info = self.witness_info(witness_id).expect(
- "witness id was returned from the contract state above, so it must be there",
- );
- match (our_outpoint, our_witness) {
- // we own both allocation and witness transaction: these allocations are changes and
- // outgoing payments. The difference between the change and the payments are whether
- // a specific allocation is listed in the first tuple pattern field.
- (Some(our_allocations), Some(all_allocations)) => {
- // all_allocations - our_allocations = external payments
- let ext_allocations = all_allocations.difference(&our_allocations);
- ops.extend(NonFungibleOp::new_sent(
- witness_info,
- ext_allocations.cloned().collect(),
- ))
- }
- // the same as above, but the payment has no change
- (None, Some(ext_allocations)) => {
- ops.extend(NonFungibleOp::new_sent(witness_info, ext_allocations))
- }
- // we own allocation but the witness transaction was made by other wallet:
- // this is an incoming payment to us.
- (Some(our_allocations), None) => {
- ops.extend(NonFungibleOp::new_received(witness_info, our_allocations))
- }
- // these can't get into the `witness_ids` due to the used filters
- (None, None) => unreachable!("broken allocation filters"),
- };
- }
-
- Ok(ops)
+ self.operations(|state| state.attach_all(), filter_outpoints, filter_witnesses)
  }
 
  pub fn witness_info(&self, witness_id: XWitnessId) -> Option<WitnessInfo> {