calc v3 pool fees

Author: jalbrekt85

fee_allocator/accounting/chains.py

@@ -244,17 +244,24 @@ def _fetch_and_process_pool_fee_data(self) -> list[PoolFeeData]:
 
         pools_data = []
 
-        core_pools_to_process = (
+        core_pools_list = (
             [(pool_id, label) for pool_id, label in self.core_pools_list.items()]
             if self.core_pools_list is not None
             else self.bal_pools_gauges.core_pools
         )
 
-        for pool_id, label in core_pools_to_process:
+        v3_pools = [(p, l) for p, l in core_pools_list if len(p) == 42]
+        v2_pools = [x for x in core_pools_list if x not in v3_pools]
+
+        for pool_id, label in v3_pools:
+                pool_fee_data = self._fetch_twap_prices_and_init_pool_fee_data_v3(pool_id, label, pool_to_gauge)
+                pools_data.append(pool_fee_data)
+
+        for pool_id, label in v2_pools:
             start_snap = self._get_latest_snapshot(start_snaps, pool_id)
             end_snap = self._get_latest_snapshot(end_snaps, pool_id)
-            if self._should_add_pool(pool_id, start_snap, end_snap):
-                pool_fee_data = self._fetch_twap_prices_and_init_pool_fee_data(pool_id, label, pool_to_gauge, start_snap, end_snap)
+            if self._should_add_pool(pool_id, start_snap, end_snap, pool_to_gauge):
+                pool_fee_data = self._fetch_twap_prices_and_init_pool_fee_data_v2(pool_id, label, pool_to_gauge, start_snap, end_snap)
                 pools_data.append(pool_fee_data)
 
         return pools_data
@@ -274,14 +281,15 @@ def _create_pool_to_gauge_mapping(self, pools: list[Pool]) -> Dict[str, str]:
         return pool_to_gauge
 
     def _should_add_pool(
-        self, pool_id: str, start_snap: PoolSnapshot, end_snap: PoolSnapshot
+        self, pool_id: str, start_snap: PoolSnapshot, end_snap: PoolSnapshot, pool_to_gauge: Dict[str, str]
     ) -> bool:
         return (
             start_snap and end_snap
             and self.bal_pools_gauges.has_alive_preferential_gauge(pool_id)
+            and pool_to_gauge.get(pool_id)
         )
 
-    def _fetch_twap_prices_and_init_pool_fee_data(
+    def _fetch_twap_prices_and_init_pool_fee_data_v2(
         self,
         pool_id: str,
         label: str,
@@ -312,6 +320,31 @@ def _fetch_twap_prices_and_init_pool_fee_data(
             end_pool_snapshot=end_snap,
             last_join_exit_ts=last_join_exit_ts,
         )
+    
+    def _fetch_twap_prices_and_init_pool_fee_data_v3(
+        self,
+        pool_id: str,
+        label: str,
+        pool_to_gauge: Dict[str, str],
+    ) -> PoolFeeData:
+        logger.info(f"fetching twap prices for {label} on {self.name}")
+
+        try:
+            last_join_exit_ts = self.bal_pools_gauges.get_last_join_exit(pool_id)
+        except NoResultError:
+            last_join_exit_ts = 0
+
+        return PoolFeeData(
+            pool_id=pool_id,
+            address=pool_id,
+            symbol=label,
+            tokens_price=None,
+            gauge_address=pool_to_gauge[pool_id],
+            start_pool_snapshot=None,
+            end_pool_snapshot=None,
+            last_join_exit_ts=last_join_exit_ts,
+            total_earned_fees_usd_twap=self.subgraph.get_v3_protocol_fees(pool_id, self.name, self.chains.date_range),
+        )
 
     @staticmethod
     def _get_latest_snapshot(

fee_allocator/accounting/core_pools.py

@@ -1,9 +1,7 @@
 from __future__ import annotations
 from dataclasses import dataclass, field
-from web3 import Web3
 from typing import List, Dict, TYPE_CHECKING
 from decimal import Decimal
-from datetime import datetime
 
 from bal_tools.models import PoolSnapshot, TWAPResult
 from fee_allocator.accounting.interfaces import AbstractPoolFee
@@ -32,55 +30,41 @@ class PoolFeeData:
     pool_id: str
     address: str
     symbol: str
-    bpt_price: Decimal
     tokens_price: List[TWAPResult]
     gauge_address: str
     start_pool_snapshot: PoolSnapshot
     end_pool_snapshot: PoolSnapshot
     last_join_exit_ts: int
-
-    earned_bpt_fee: Decimal = field(init=False)
-    earned_bpt_fee_usd_twap: Decimal = field(init=False)
-    earned_tokens_fee: Dict[str, Decimal] = field(init=False)
-    earned_tokens_fee_usd_twap: Decimal = field(init=False)
-    total_earned_fees_usd_twap: Decimal = field(init=False)
+    bpt_price: Decimal = field(default=Decimal(0))
+    total_earned_fees_usd_twap: Decimal = None
 
     def __post_init__(self):
-        self.earned_bpt_fee = self._set_earned_bpt_fee()
-        self.earned_bpt_fee_usd_twap = self._set_earned_bpt_fee_usd_twap()
-        self.earned_tokens_fee = self._set_earned_tokens_fee()
-        self.earned_tokens_fee_usd_twap = self._set_earned_tokens_fee_usd_twap()
-        self.total_earned_fees_usd_twap = self._set_total_earned_fees_usd_twap()
-
-    def _set_earned_bpt_fee(self) -> Decimal:
-        return (
+        if len(self.pool_id) == 42:
+            # v3 pool; earned fees already calculated
+            if  self.total_earned_fees_usd_twap is None:
+                raise ValueError(f"v3 pool {self.pool_id} must have total_earned_fees_usd_twap set. got {self.total_earned_fees_usd_twap}")
+        else:
+            # v2 pool
+            self.total_earned_fees_usd_twap = self._set_total_earned_fees_usd_twap_v2()
+
+    def _set_total_earned_fees_usd_twap_v2(self) -> Decimal:
+        bpt_fee = (
             self.end_pool_snapshot.totalProtocolFeePaidInBPT
             - self.start_pool_snapshot.totalProtocolFeePaidInBPT
         )
+        if bpt_fee > 0:
+            return self.bpt_price * bpt_fee
 
-    def _set_earned_bpt_fee_usd_twap(self) -> Decimal:
-        return self.bpt_price * self.earned_bpt_fee
-
-    def _set_earned_tokens_fee(self) -> Dict[str, Decimal]:
-        return {
-            end_token.address: Decimal(
-                end_token.paidProtocolFees - start_token.paidProtocolFees
-            )
-            for start_token, end_token in zip(
-                self.start_pool_snapshot.tokens, self.end_pool_snapshot.tokens
-            )
-        }
-
-    def _set_earned_tokens_fee_usd_twap(self) -> Decimal:
         return sum(
-            token.twap_price * fee
-            for fee, token in zip(self.earned_tokens_fee.values(), self.tokens_price)
-            if fee > 0
+            token.twap_price * Decimal(end_token.paidProtocolFees - start_token.paidProtocolFees)
+            for end_token, start_token, token in zip(
+                self.end_pool_snapshot.tokens,
+                self.start_pool_snapshot.tokens,
+                self.tokens_price
+            )
+            if end_token.paidProtocolFees > start_token.paidProtocolFees
         )
 
-    def _set_total_earned_fees_usd_twap(self) -> Decimal:
-        return self.earned_bpt_fee_usd_twap + self.earned_tokens_fee_usd_twap
-
 
 class PoolFee(AbstractPoolFee, PoolFeeData):
     """

requirements.txt

@@ -7,4 +7,5 @@ gql[requests]
 pandas==2.0.3
 numpy==1.26.4
 json-fix
-git+https://github.com/BalancerMaxis/bal_addresses@main
+# git+https://github.com/BalancerMaxis/bal_addresses@main
+git+https://github.com/BalancerMaxis/bal_tools@v3-pool-fees