Iterable FeeInfo

Closes #1659.

sequencer/src/bin/nasty-client.rs

@@ -929,7 +929,10 @@ impl ResourceManager<Header> {
                     .await
             })
             .await?;
-        let builder_address = builder_header.fee_info().account();
+
+        // Since we have multiple fee accounts, we need to select one.
+        let accounts = builder_header.fee_info().accounts();
+        let builder_address = accounts.first().unwrap();
 
         // Get the header of the state snapshot we're going to query so we can later verify our
         // results.

sequencer/src/state.rs

@@ -412,7 +412,7 @@ mod test {
             ProposalValidationError::InsufficientFee {
                 max_block_size: instance.chain_config.max_block_size,
                 base_fee: instance.chain_config.base_fee,
-                proposed_fee: header.fee_info().amount()
+                proposed_fee: header.fee_info().amount().unwrap()
             },
             err
         );

types/src/reference_tests.rs

@@ -142,8 +142,8 @@ async fn reference_header(version: Version) -> Header {
         ns_table,
         state.fee_merkle_tree.commitment(),
         state.block_merkle_tree.commitment(),
-        fee_info,
-        Some(builder_signature),
+        vec![fee_info],
+        vec![builder_signature],
         version,
     )
 }

types/src/v0/impls/fee_info.rs

@@ -14,6 +14,7 @@ use ethers::{
 };
 use hotshot_query_service::explorer::MonetaryValue;
 use hotshot_types::traits::block_contents::BuilderFee;
+use itertools::Itertools;
 use jf_merkle_tree::{
     ForgetableMerkleTreeScheme, ForgetableUniversalMerkleTreeScheme, LookupResult,
     MerkleCommitment, MerkleTreeError, MerkleTreeScheme, ToTraversalPath,
@@ -26,8 +27,9 @@ use sequencer_utils::{
 use thiserror::Error;
 
 use crate::{
-    eth_signature_key::EthKeyPair, AccountQueryData, FeeAccount, FeeAccountProof, FeeAmount,
-    FeeInfo, FeeMerkleCommitment, FeeMerkleProof, FeeMerkleTree, SeqTypes,
+    eth_signature_key::EthKeyPair, v0_3::IterableFeeInfo, AccountQueryData, FeeAccount,
+    FeeAccountProof, FeeAmount, FeeInfo, FeeMerkleCommitment, FeeMerkleProof, FeeMerkleTree,
+    SeqTypes,
 };
 
 /// Possible charge fee failures
@@ -59,11 +61,12 @@ impl FeeInfo {
         }
     }
 
-    pub fn genesis() -> Self {
-        Self {
+    pub fn genesis() -> Vec<Self> {
+        let info = Self {
             account: Default::default(),
             amount: Default::default(),
-        }
+        };
+        vec![info]
     }
 
     pub fn account(&self) -> FeeAccount {
@@ -73,6 +76,48 @@ impl FeeInfo {
     pub fn amount(&self) -> FeeAmount {
         self.amount
     }
+    /// Get a `Vec<FeeInfo>` from `Vec<BuilderFee>`
+    pub fn from_builder_fees(fees: Vec<BuilderFee<SeqTypes>>) -> Vec<FeeInfo> {
+        fees.into_iter().map(FeeInfo::from).collect()
+    }
+}
+
+impl IterableFeeInfo for Vec<FeeInfo> {
+    /// Get sum of fee amounts
+    fn amount(&self) -> Option<FeeAmount> {
+        self.iter()
+            // getting the u64 tests that the value fits
+            .map(|fee_info| fee_info.amount.as_u64())
+            .collect::<Option<Vec<u64>>>()
+            .and_then(|amounts| amounts.iter().try_fold(0u64, |acc, n| acc.checked_add(*n)))
+            .map(FeeAmount::from)
+    }
+
+    /// Get a `Vec` of all unique fee accounts
+    fn accounts(&self) -> Vec<FeeAccount> {
+        self.iter()
+            .unique_by(|entry| &entry.account)
+            .map(|entry| entry.account)
+            .collect()
+    }
+}
+
+impl IterableFeeInfo for Vec<BuilderFee<SeqTypes>> {
+    /// Get sum of amounts
+    fn amount(&self) -> Option<FeeAmount> {
+        self.iter()
+            .map(|fee_info| fee_info.fee_amount)
+            .try_fold(0u64, |acc, n| acc.checked_add(n))
+            .map(FeeAmount::from)
+    }
+
+    /// Get a `Vec` of all unique fee accounts
+    fn accounts(&self) -> Vec<FeeAccount> {
+        self.iter()
+            .unique_by(|entry| &entry.fee_account)
+            .map(|entry| entry.fee_account)
+            .collect()
+    }
 }
 
 impl From<BuilderFee<SeqTypes>> for FeeInfo {
@@ -375,3 +420,27 @@ impl From<(FeeAccountProof, U256)> for AccountQueryData {
         Self { balance, proof }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use ethers::abi::Address;
+
+    use crate::{FeeAccount, FeeAmount, FeeInfo};
+
+    use super::IterableFeeInfo;
+
+    // TODO find out where this test should go in versioned code
+    #[test]
+    fn test_iterable_fee_info() {
+        let addr = Address::zero();
+        let fee = FeeInfo::new(addr, FeeAmount::from(1));
+        let fees = vec![fee, fee, fee];
+        // check the sum of amounts
+        let sum = fees.amount().unwrap();
+        assert_eq!(FeeAmount::from(3), sum);
+
+        // check acounts collector
+        let accounts = fees.accounts();
+        assert_eq!(vec![FeeAccount::from(Address::zero())], accounts);
+    }
+}