Compute partner fees

src/constants.py

@@ -18,6 +18,8 @@
     "0x875b6cb035bbd4ac6500fabc6d1e4ca5bdc58a3e2b424ccb5c24cdbebeb009a9"
 )
 
+NULL_ADDRESS = Web3.to_checksum_address("0x0000000000000000000000000000000000000000")
+
 REQUEST_TIMEOUT = 5
 
 # Time limit, currently set to 1 full day, after which Coingecko Token List is re-fetched (in seconds)

src/fees/compute_fees.py

@@ -5,14 +5,14 @@
 import math
 import os
 from typing import Any
+import requests
+import json
 from dotenv import load_dotenv
-from eth_typing import Address
+from eth_typing import ChecksumAddress
 from hexbytes import HexBytes
+from web3 import Web3
 
-from src.constants import (
-    REQUEST_TIMEOUT,
-)
-import requests
+from src.constants import REQUEST_TIMEOUT, NULL_ADDRESS
 
 # types for trades
 
@@ -21,17 +21,39 @@
 class Trade:
     """Class for"""
 
-    order_uid: HexBytes
-    sell_amount: int
-    buy_amount: int
-    sell_token: HexBytes
-    buy_token: HexBytes
-    limit_sell_amount: int
-    limit_buy_amount: int
-    kind: str
-    sell_token_clearing_price: int
-    buy_token_clearing_price: int
-    fee_policies: list["FeePolicy"]
+    def __init__(
+        self,
+        order_uid: HexBytes,
+        sell_amount: int,
+        buy_amount: int,
+        sell_token: HexBytes,
+        buy_token: HexBytes,
+        limit_sell_amount: int,
+        limit_buy_amount: int,
+        kind: str,
+        sell_token_clearing_price: int,
+        buy_token_clearing_price: int,
+        fee_policies: list["FeePolicy"],
+        partner_fee_recipient: ChecksumAddress,
+    ):
+        self.order_uid = order_uid
+        self.sell_amount = sell_amount
+        self.buy_amount = buy_amount
+        self.sell_token = sell_token
+        self.buy_token = buy_token
+        self.limit_sell_amount = limit_sell_amount
+        self.limit_buy_amount = limit_buy_amount
+        self.kind = kind
+        self.sell_token_clearing_price = sell_token_clearing_price
+        self.buy_token_clearing_price = buy_token_clearing_price
+        self.fee_policies = fee_policies
+        self.partner_fee_recipient = partner_fee_recipient  # if there is no partner, then its value is set to the null address
+
+        total_protocol_fee, partner_fee, network_fee = self.compute_all_fees()
+        self.total_protocol_fee = total_protocol_fee
+        self.partner_fee = partner_fee
+        self.network_fee = network_fee
+        return
 
     def volume(self) -> int:
         """Compute volume of a trade in the surplus token"""
@@ -62,20 +84,31 @@ def surplus(self) -> int:
             return current_limit_sell_amount - self.sell_amount
         raise ValueError(f"Order kind {self.kind} is invalid.")
 
-    def raw_surplus(self) -> int:
-        """Compute raw surplus of a trade in the surplus token
-        First, the application of protocol fees is reversed. Then, surplus of the resulting trade
-        is computed."""
+    def compute_all_fees(self) -> tuple[int, int, int]:
         raw_trade = deepcopy(self)
-        for fee_policy in reversed(self.fee_policies):
-            raw_trade = fee_policy.reverse_protocol_fee(raw_trade)
-        return raw_trade.surplus()
-
-    def protocol_fee(self):
-        """Compute protocol fees of a trade in the surplus token
-        Protocol fees are computed as the difference of raw surplus and surplus."""
-
-        return self.raw_surplus() - self.surplus()
+        total_protocol_fee = 0
+        partner_fee = 0
+        network_fee = 0
+        if self.fee_policies:
+            for i, fee_policy in enumerate(reversed(self.fee_policies)):
+                raw_trade = fee_policy.reverse_protocol_fee(raw_trade)
+                ## we assume that partner fee is the last to be applied
+                if i == 0 and self.partner_fee_recipient is not NULL_ADDRESS:
+                    partner_fee = raw_trade.surplus() - self.surplus()
+            total_protocol_fee = raw_trade.surplus() - self.surplus()
+
+        surplus_fee = self.compute_surplus_fee()  # in the surplus token
+        network_fee_in_surplus_token = surplus_fee - self.total_protocol_fee
+        if self.kind == "sell":
+            network_fee = int(
+                network_fee_in_surplus_token
+                * Fraction(
+                    self.buy_token_clearing_price, self.sell_token_clearing_price
+                )
+            )
+        else:
+            network_fee = network_fee_in_surplus_token
+        return total_protocol_fee, partner_fee, network_fee
 
     def surplus_token(self) -> HexBytes:
         """Returns the surplus token"""
@@ -336,6 +369,14 @@ def get_all_data(self, tx_hash: HexBytes) -> SettlementData:
             buy_token_clearing_price = clearing_prices[buy_token]
             fee_policies = self.parse_fee_policies(trade_data["feePolicies"])
 
+            app_data = json.loads(order_data["fullAppData"])
+            if "partnerFee" in app_data["metadata"].keys():
+                partner_fee_recipient = Web3.to_checksum_address(
+                    HexBytes(app_data["metadata"]["partnerFee"]["recipient"])
+                )
+            else:
+                partner_fee_recipient = NULL_ADDRESS
+
             trade = Trade(
                 order_uid=uid,
                 sell_amount=executed_sell_amount,
@@ -348,6 +389,7 @@ def get_all_data(self, tx_hash: HexBytes) -> SettlementData:
                 sell_token_clearing_price=sell_token_clearing_price,
                 buy_token_clearing_price=buy_token_clearing_price,
                 fee_policies=fee_policies,
+                partner_fee_recipient=partner_fee_recipient,
             )
             trades.append(trade)
 
@@ -436,48 +478,35 @@ def parse_fee_policies(
         return fee_policies
 
 
-# computing fees
-def compute_fee_imbalances(
-    settlement_data: SettlementData,
-) -> tuple[dict[str, tuple[str, int]], dict[str, tuple[str, int]]]:
+# function that computes all fees of all orders in a batch
+# Note that currently it is NOT working for CoW AMMs as they are not indexed.
+def compute_all_fees_of_batch(
+    tx_hash: HexBytes,
+) -> tuple[
+    dict[str, tuple[str, int]],
+    dict[str, tuple[str, int, str]],
+    dict[str, tuple[str, int]],
+]:
+    orderbook_api = OrderbookFetcher()
+    settlement_data = orderbook_api.get_all_data(tx_hash)
     protocol_fees: dict[str, tuple[str, int]] = {}
     network_fees: dict[str, tuple[str, int]] = {}
+    partner_fees: dict[str, tuple[str, int, str]] = {}
     for trade in settlement_data.trades:
         # protocol fees
-        protocol_fee_amount = trade.protocol_fee()
+        protocol_fee_amount = trade.total_protocol_fee - trade.partner_fee
         protocol_fee_token = trade.surplus_token()
         protocol_fees[trade.order_uid.to_0x_hex()] = (
             protocol_fee_token.to_0x_hex(),
             protocol_fee_amount,
         )
-        # network fees
-        surplus_fee = trade.compute_surplus_fee()  # in the surplus token
-        network_fee = surplus_fee - protocol_fee_amount
-        if trade.kind == "sell":
-            network_fee_sell = int(
-                network_fee
-                * Fraction(
-                    trade.buy_token_clearing_price, trade.sell_token_clearing_price
-                )
-            )
-        else:
-            network_fee_sell = network_fee
-
+        partner_fees[trade.order_uid.to_0x_hex()] = (
+            protocol_fee_token.to_0x_hex(),
+            trade.partner_fee,
+            trade.partner_fee_recipient,
+        )
         network_fees[trade.order_uid.to_0x_hex()] = (
             trade.sell_token.to_0x_hex(),
-            network_fee_sell,
+            trade.network_fee,
         )
-
-    return protocol_fees, network_fees
-
-
-# combined function
-
-
-def batch_fee_imbalances(
-    tx_hash: HexBytes,
-) -> tuple[dict[str, tuple[str, int]], dict[str, tuple[str, int]]]:
-    orderbook_api = OrderbookFetcher()
-    settlement_data = orderbook_api.get_all_data(tx_hash)
-    protocol_fees, network_fees = compute_fee_imbalances(settlement_data)
-    return protocol_fees, network_fees
+    return protocol_fees, partner_fees, network_fees

src/helpers/database.py

@@ -97,22 +97,29 @@ def write_fees(
         token_address: str,
         fee_amount: float,
         fee_type: str,
+        recipient: str,
     ):
         """Function attempts to write price data to the table."""
         tx_hash_bytes = bytes.fromhex(tx_hash[2:])
         token_address_bytes = bytes.fromhex(token_address[2:])
         order_uid_bytes = bytes.fromhex(order_uid[2:])
+
         query = read_sql_file("src/sql/insert_fee.sql")
+        final_recipient = None
+        if recipient != "":
+            final_recipient = bytes.fromhex(recipient[2:])
+
         self.execute_and_commit(
             query,
             {
-                "chain_name": self.chain_name,
+                "chain_name": chain_name,
                 "auction_id": auction_id,
                 "block_number": block_number,
                 "tx_hash": tx_hash_bytes,
                 "order_uid": order_uid_bytes,
                 "token_address": token_address_bytes,
                 "fee_amount": fee_amount,
                 "fee_type": fee_type,
+                "recipient": final_recipient,
             },
         )

src/test_single_hash.py

@@ -2,7 +2,7 @@
 from web3 import Web3
 from src.imbalances_script import RawTokenImbalances
 from src.price_providers.price_feed import PriceFeed
-from src.fees.compute_fees import batch_fee_imbalances
+from src.fees.compute_fees import compute_all_fees_of_batch
 from src.transaction_processor import calculate_slippage
 from src.helpers.config import get_web3_instance, logger
 from contracts.erc20_abi import erc20_abi
@@ -26,7 +26,9 @@ def __init__(self):
 
     def compute_data(self, tx_hash: str):
         token_imbalances = self.imbalances.compute_imbalances(tx_hash)
-        protocol_fees, network_fees = batch_fee_imbalances(HexBytes(tx_hash))
+        protocol_fees, partner_fees, network_fees = compute_all_fees_of_batch(
+            HexBytes(tx_hash)
+        )
         slippage = calculate_slippage(token_imbalances, protocol_fees, network_fees)
         eth_slippage = self.calculate_slippage_in_eth(slippage, tx_hash)
 

src/transaction_processor.py

@@ -6,7 +6,7 @@
 from src.price_providers.price_feed import PriceFeed
 from src.helpers.helper_functions import read_sql_file, set_params
 from src.helpers.config import CHAIN_SLEEP_TIME, logger
-from src.fees.compute_fees import batch_fee_imbalances
+from src.fees.compute_fees import compute_all_fees_of_batch
 import time
 
 
@@ -109,9 +109,11 @@ def process_single_transaction(
 
             # Compute Fees
             if self.process_fees:
-                protocol_fees, network_fees = self.process_fees_for_transaction(
-                    tx_hash, auction_id, block_number
-                )
+                (
+                    protocol_fees,
+                    partner_fees,
+                    network_fees,
+                ) = self.process_fees_for_transaction(tx_hash)
 
             # Compute Prices
             if self.process_prices:
@@ -134,7 +136,12 @@ def process_single_transaction(
 
             if self.process_fees:
                 self.handle_fees(
-                    protocol_fees, network_fees, auction_id, block_number, tx_hash
+                    protocol_fees,
+                    partner_fees,
+                    network_fees,
+                    auction_id,
+                    block_number,
+                    tx_hash,
                 )
 
             if self.process_prices and prices:
@@ -162,15 +169,22 @@ def process_token_imbalances(
             return {}
 
     def process_fees_for_transaction(
-        self, tx_hash: str, auction_id: int, block_number: int
-    ) -> tuple[dict[str, tuple[str, int]], dict[str, tuple[str, int]]]:
+        self,
+        tx_hash: str,
+    ) -> tuple[
+        dict[str, tuple[str, int]],
+        dict[str, tuple[str, int, str]],
+        dict[str, tuple[str, int]],
+    ]:
         """Process and return protocol and network fees for a given transaction."""
         try:
-            protocol_fees, network_fees = batch_fee_imbalances(HexBytes(tx_hash))
-            return protocol_fees, network_fees
+            protocol_fees, partner_fees, network_fees = compute_all_fees_of_batch(
+                HexBytes(tx_hash)
+            )
+            return protocol_fees, partner_fees, network_fees
         except Exception as e:
             logger.error(f"Failed to process fees for transaction {tx_hash}: {e}")
-            return {}, {}
+            return {}, {}, {}
 
     def process_prices_for_tokens(
         self,
@@ -224,6 +238,7 @@ def handle_imbalances(
     def handle_fees(
         self,
         protocol_fees: dict[str, tuple[str, int]],
+        partner_fees: dict[str, tuple[str, int, str]],
         network_fees: dict[str, tuple[str, int]],
         auction_id: int,
         block_number: int,
@@ -242,6 +257,25 @@ def handle_fees(
                     token_address=token_address,
                     fee_amount=float(fee_amount),
                     fee_type="protocol",
+                    recipient="",
+                )
+
+            # Write partner fees
+            for order_uid, (
+                token_address,
+                fee_amount,
+                recipient,
+            ) in partner_fees.items():
+                self.db.write_fees(
+                    chain_name=self.chain_name,
+                    auction_id=auction_id,
+                    block_number=block_number,
+                    tx_hash=tx_hash,
+                    order_uid=order_uid,
+                    token_address=token_address,
+                    fee_amount=float(fee_amount),
+                    fee_type="partner",
+                    recipient=recipient,
                 )
 
             # Write network fees
@@ -255,6 +289,7 @@ def handle_fees(
                     token_address=token_address,
                     fee_amount=float(fee_amount),
                     fee_type="network",
+                    recipient="",
                 )
         except Exception as err:
             logger.error(