separate v2 and v3 fees

Author: jalbrekt85

combine_payloads.py

@@ -0,0 +1,53 @@
+import argparse
+import json
+from pathlib import Path
+from datetime import datetime
+
+
+def combine_payloads(fees_file_name: str) -> None:
+    date_str = fees_file_name.split('_')[1].split('.')[0]
+    
+    payload_dir = Path("fee_allocator/payloads")
+    
+    v2_file = payload_dir / f"v2_{date_str}.json"
+    v3_file = payload_dir / f"v3_{date_str}.json"
+    
+    if not v2_file.exists() or not v3_file.exists():
+        raise FileNotFoundError(f"Could not find both v2 and v3 payload files for date {date_str}")
+    
+    with open(v2_file) as f:
+        v2_payload = json.load(f)
+    
+    with open(v3_file) as f:
+        v3_payload = json.load(f)
+    
+    combined_payload = {
+        "version": "1.0",
+        "chainId": "1",
+        "createdAt": int(datetime.now().timestamp()),
+        "meta": {
+            "name": "Combined V2+V3 Transactions Batch",
+            "description": "",
+            "txBuilderVersion": "1.16.3",
+            "createdFromSafeAddress": v2_payload["meta"]["createdFromSafeAddress"],
+            "createdFromOwnerAddress": "",
+            "checksum": "0x0000000000000000000000000000000000000000000000000000000000000000"
+        },
+        "transactions": v2_payload["transactions"] + v3_payload["transactions"]
+    }
+    
+    output_file = payload_dir / f"{date_str}.json"
+    with open(output_file, "w") as f:
+        json.dump(combined_payload, f, indent=2)
+    
+    print(f"Combined payload written to {output_file}")
+    print(f"Total transactions: {len(combined_payload['transactions'])}")
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--payload_file_name", help="Fees file name", type=str, required=True)
+    args = parser.parse_args()
+    combine_payloads(args.payload_file_name)
+
+if __name__ == "__main__":
+    main() 

fee_allocator/accounting/chains.py

@@ -53,6 +53,7 @@ def __init__(
         cache_dir: Path = None,
         use_cache: bool = True,
         core_pools: Dict[str, Dict[str, str]] = None,
+        protocol_version: str = "v2",
     ):
         # convert wei fees to usd. identified by the lack of a decimal point
         self.input_fees = {chain: fee / 1e6 if isinstance(fee, int) else fee for chain, fee in input_fees.items()}
@@ -70,6 +71,7 @@ def __init__(
 
         self._chains: Union[dict[str, CorePoolChain], None] = None
         self.aura_vebal_share: Union[Decimal, None] = None
+        self.protocol_version = protocol_version
 
 
     def __getattr__(self, name):
@@ -250,19 +252,20 @@ def _fetch_and_process_pool_fee_data(self) -> list[PoolFeeData]:
             else self.bal_pools_gauges.core_pools
         )
 
-        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:
+        if self.chains.protocol_version == "v3":
+            v3_pools = [(p, l) for p, l in core_pools_list if len(p) == 42]
+            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_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)
+        elif self.chains.protocol_version == "v2":
+            v2_pools = [(p, l) for p, l in core_pools_list if len(p) != 42]
+            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_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
 

fee_allocator/fee_allocator.py

@@ -47,6 +47,7 @@ def __init__(
         cache_dir: Path = None,
         use_cache: bool = True,
         core_pools: Dict[str, Dict[str, str]] = None,
+        protocol_version: str = "v2",
     ):
         self.input_fees = input_fees
         self.date_range = date_range
@@ -56,6 +57,7 @@ def __init__(
             cache_dir=cache_dir,
             use_cache=use_cache,
             core_pools=core_pools,
+            protocol_version=protocol_version,
         )
         self.book = AddrBook("mainnet").flatbook
 
@@ -114,9 +116,9 @@ def redistribute_fees(self):
                 pool.to_aura_incentives_usd += total * self.run_config.aura_vebal_share
                 pool.to_bal_incentives_usd += total * (1 - self.run_config.aura_vebal_share)
 
-            for pool in chain.core_pools:
-                pool.to_dao_usd = pool.original_earned_fee_share * chain.fees_collected * self.run_config.fee_config.dao_share_pct
-                pool.to_vebal_usd = pool.original_earned_fee_share * chain.fees_collected * self.run_config.fee_config.vebal_share_pct
+            # for pool in chain.core_pools:
+            #     pool.to_dao_usd = pool.original_earned_fee_share * chain.fees_collected * self.run_config.fee_config.dao_share_pct
+            #     pool.to_vebal_usd = pool.original_earned_fee_share * chain.fees_collected * self.run_config.fee_config.vebal_share_pct
 
         self._handle_aura_min(buffer=0.25)
         self._handle_aura_min()
@@ -220,7 +222,7 @@ def generate_bribe_csv(
         datetime_file_header = datetime.datetime.fromtimestamp(
             self.date_range[1]
         ).date()
-        output_path = PROJECT_ROOT / output_path / f"bribes_{datetime_file_header}.csv"
+        output_path = PROJECT_ROOT / output_path / f"{self.run_config.protocol_version}_bribes_{datetime_file_header}.csv"
         output_path.parent.mkdir(exist_ok=True)
 
         df.to_csv(
@@ -262,7 +264,7 @@ def generate_incentives_csv(
         start_date = datetime.datetime.fromtimestamp(self.date_range[0]).date()
         end_date = datetime.datetime.fromtimestamp(self.date_range[1]).date()
         output_path = (
-            PROJECT_ROOT / output_path / f"incentives_{start_date}_{end_date}.csv"
+            PROJECT_ROOT / output_path / f"{self.run_config.protocol_version}_incentives_{start_date}_{end_date}.csv"
         )
         output_path.parent.mkdir(exist_ok=True)
 
@@ -342,7 +344,7 @@ def generate_bribe_payload(
             self.date_range[1]
         ).date()
 
-        output_path = PROJECT_ROOT / output_path / f"{datetime_file_header}.json"
+        output_path = PROJECT_ROOT / output_path / f"{self.run_config.protocol_version}_{datetime_file_header}.json"
         output_path.parent.mkdir(exist_ok=True)
         builder.output_payload(output_path)
 
@@ -418,7 +420,7 @@ def recon(self) -> None:
             "periodEnd": self.date_range[1]
         }
 
-        recon_file = Path(PROJECT_ROOT) / "fee_allocator/summaries/recon.json"
+        recon_file = Path(PROJECT_ROOT) / "fee_allocator/summaries" / f"{self.run_config.protocol_version}_recon.json"
         recon_file.parent.mkdir(exist_ok=True)
 
         if recon_file.exists():

fee_allocator/fees_collected/get_report.py

@@ -21,21 +21,31 @@ def get_report(start_date, end_date):
         },
     )
     response.raise_for_status()
+    # breakpoint()
     report = response.json()["depositors"]
+    total = 0
     for chain, amount in report.items():
         report[chain] = int(amount)
-    return report
+        total += int(amount)
+    if total > 0:
+        return report
+    else:
+        raise ValueError("Sum of collected fees is not > 0")
 
 
 if __name__ == "__main__":
     # run this every other thursday after the end of an epoch
     today = datetime.now()
-    yesterday = today - timedelta(days=1)
-    epoch_start = today - timedelta(days=14)
-
-    report = get_report(yesterday.strftime("%Y-%m-%d"), today.strftime("%Y-%m-%d"))
-    with open(
-        f"fee_allocator/fees_collected/fees_{epoch_start.strftime('%Y-%m-%d')}_{today.strftime('%Y-%m-%d')}.json",
-        "w",
-    ) as f:
-        json.dump(report, f, indent=2)
+
+    if bool(int(today.strftime("%V")) % 2):
+        # week number is uneven; there should be a new report
+
+        yesterday = today - timedelta(days=1)
+        epoch_start = today - timedelta(days=14)
+
+        report = get_report(yesterday.strftime("%Y-%m-%d"), today.strftime("%Y-%m-%d"))
+        with open(
+            f"fee_allocator/fees_collected/fees_{epoch_start.strftime('%Y-%m-%d')}_{today.strftime('%Y-%m-%d')}.json",
+            "w",
+        ) as f:
+            json.dump(report, f, indent=2)

main.py

@@ -18,6 +18,7 @@
     "--output_file_name", help="Output file name", type=str, required=False
 )
 parser.add_argument("--fees_file_name", help="Fees file name", type=str, required=False)
+parser.add_argument("--protocol_version", help="Protocol version (v2 or v3)", type=str, choices=["v2", "v3"], default="v2")
 
 ROOT = os.path.dirname(__file__)
 
@@ -42,8 +43,8 @@ def main() -> None:
     input_fees = fetch_collected_fees(start_date, end_date, args.fees_file_name)
     date_range = (ts_in_the_past, ts_now)
 
-    fee_allocator = FeeAllocator(input_fees, date_range)
-    
+    fee_allocator = FeeAllocator(input_fees, date_range, protocol_version=args.protocol_version)
+
     fee_allocator.allocate()
     fee_allocator.recon()