Add: checks

Author: DJercic

integrations/silo_finance.py

@@ -0,0 +1,51 @@
+import logging
+from rich.console import Console
+
+from constants.silo_finance import SILO_FINANCE_INTEGRATION_ID_TO_START_BLOCK
+from constants.summary_columns import SummaryColumn
+from integrations.integration_ids import IntegrationID as IntID
+from constants.chains import Chain
+from utils.silo_finance import SiloFinance
+
+logger = logging.getLogger("Silo Finance LP-eUSDe")
+logger.setLevel(logging.INFO)
+
+if __name__ == "__main__":
+    console = Console()
+
+    integration = SiloFinance(
+        integration_id=IntID.SILO_FINANCE_LP_SUSDE_SEP_25_EXPIRY,
+        start_block=SILO_FINANCE_INTEGRATION_ID_TO_START_BLOCK[
+            IntID.SILO_FINANCE_LP_SUSDE_SEP_25_EXPIRY
+        ],
+        chain=Chain.ETHEREUM,
+        summary_cols=[SummaryColumn.SILO_FINANCE_LP_SUSDE_SEP_25_EXPIRY_PTS],
+        reward_multiplier=30,
+        balance_multiplier=1,
+    )
+
+    # Without cached data
+    without_cached_data_output = integration.get_block_balances(
+        cached_data={}, blocks=[22693183, 22755000]
+    )
+    console.print("Run without cached data", without_cached_data_output)
+    # Check that the output is correct~ish
+    assert without_cached_data_output[22755000] == {
+        "0x62a4A8f9f5F3AaE9Ee9CEE780285A0D501C12d09": 18.194513,
+        "0xeb80e76443c1bFa85dF46075f52a43ae1572003a": 30578.64522,
+    }
+
+    # Use cache data to get the next blocks
+    with_cached_data_output = integration.get_block_balances(
+        cached_data=without_cached_data_output,
+        blocks=[22814115],
+    )
+    console.print("Run with cached data", with_cached_data_output)
+    assert with_cached_data_output[22814115] == {
+        "0x62a4A8f9f5F3AaE9Ee9CEE780285A0D501C12d09": 18.194513,
+        "0xeb80e76443c1bFa85dF46075f52a43ae1572003a": 30578.64522,
+        "0x432FD970d8867b56e7197290BCd03C92A325AB7b": 620.451445,
+        "0xdD84Ce1aDcb3A4908Db61A1dFA3353C3974c5a2B": 145426.301041,
+        "0x8467241838Bc761D9Ef4F8ae6790Ede292fbA2F9": 1e-6,
+        "0x23ce39C9AB29D00fCa9B83a50F64A67837c757C5": 4759.421793,
+    }

integrations/silo_finance_lp_susde_sept.py

@@ -26,6 +26,10 @@ class SiloFinance(CachedBalancesIntegration):
     def get_market(self) -> SiloFinanceMarket:
         return SILO_FINANCE_INTEGRATION_ID_TO_MARKET[self.integration_id]
 
+    def get_silo_contract(self) -> Contract:
+        market = self.get_market()
+        return get_silo_contract(chain=self.chain, market=market)
+
     def get_logger(self) -> logging.Logger:
         logger = logging.getLogger(self.integration_id.get_column_name())
         logger.setLevel(logging.INFO)
@@ -36,7 +40,7 @@ def get_block_balances(
     ) -> Dict[int, Dict[ChecksumAddress, float]]:
         logger = self.get_logger()
         market = self.get_market()
-        logger.warning(f"Getting block data for Silo Finance {market.address}")
+        logger.info(f"Getting block data for Silo Finance {market.address}")
         new_block_data: Dict[int, Dict[ChecksumAddress, float]] = {}
         if not blocks:
             logging.error(
@@ -56,29 +60,28 @@ def get_block_balances(
                     f"Found closest cached data for block {block}: {prev_block}"
                 )
                 start = prev_block + 1
+            supply_index = self.fetch_supply_index(block)
+            logger.info(f"Supply index on block {block}: {supply_index}")
             while start <= block:
                 to_block = min(start + PAGINATION_SIZE, block)
                 logger.info(
                     f"fetching transfers for market {market.address} from block {start} to block {to_block}"
                 )
+                # Transfers are used to keep track of the user positions.
                 for transfer in self.fetch_transfers(
                     market=market, from_block=start, to_block=to_block
                 ):
-                    self.process_transfer_event(transfer=transfer, bals=bals)
+                    self.process_transfer_event(
+                        transfer=transfer, bals=bals, supply_index=supply_index
+                    )
                 start = to_block + 1
-                logger.info(
+                logger.warning(
                     f"processed transfers for market {market.address} from block {start} to block {to_block}"
                 )
             new_block_data[block] = bals
             cache_copy[block] = bals
         return new_block_data
 
-    """
-    Find the closest cached data for a given block.
-    Returns the block number and the cached data for that block. Create a new instance of the cached data to allow mutations.
-    If no cached data is found, returns None.
-    """
-
     def find_closest_cached_data(
         self, block: int, cached_data: Dict[int, Dict[ChecksumAddress, float]]
     ) -> Optional[Tuple[int, Dict[ChecksumAddress, float]]]:
@@ -91,6 +94,20 @@ def find_closest_cached_data(
                 return (existing_block, deepcopy(cached_data[existing_block]))
         return None
 
+    def fetch_supply_index(self, block: int) -> float:
+        """
+        Supply index is the number of assets that 1 share is worth. It's used to convert between shares and assets.
+        1 shares = 1 * supply_index (assets)
+        """
+        market = self.get_market()
+        silo_contract = self.get_silo_contract()
+        return (
+            silo_contract.functions.convertToAssets(10**market.shares_decimals).call(
+                block_identifier=block
+            )
+            / 10**market.shares_decimals
+        )
+
     def fetch_transfers(
         self, *, market: SiloFinanceMarket, from_block: int, to_block: int
     ):
@@ -115,21 +132,43 @@ def fetch_transfers(
         )
 
     def process_transfer_event(
-        self, *, transfer: Dict, bals: Dict[ChecksumAddress, float]
+        self,
+        *,
+        transfer: Dict,
+        bals: Dict[ChecksumAddress, float],
+        supply_index: float,
     ):
         sender = transfer["args"]["from"]
         receiver = transfer["args"]["to"]
         value = transfer["args"]["value"]
         if is_null_address(sender):
             # Minting
-            add_to_bals(bals=bals, address=receiver, value=value, decimals=18)
+            add_to_bals(
+                bals=bals,
+                address=receiver,
+                value=value * supply_index,
+                decimals=18,
+            )
         elif is_null_address(receiver):
             # Burning
-            subtract_from_bals(bals=bals, address=sender, value=value, decimals=18)
+            subtract_from_bals(
+                bals=bals, address=sender, value=value * supply_index, decimals=18
+            )
         else:
             # Transfer
-            add_to_bals(bals=bals, address=sender, value=value, decimals=18)
-            subtract_from_bals(bals=bals, address=receiver, value=value, decimals=18)
+            # Convert to assets
+            add_to_bals(
+                bals=bals,
+                address=sender,
+                value=value * supply_index,
+                decimals=18,
+            )
+            subtract_from_bals(
+                bals=bals, address=receiver, value=value * supply_index, decimals=18
+            )
+
+
+ROUND_DECIMALS = 6
 
 
 def is_null_address(address: ChecksumAddress) -> bool:
@@ -144,7 +183,8 @@ def add_to_bals(
 ):
     if address not in bals:
         bals[address] = 0
-    bals[address] += round(value / 10**decimals, 6)
+    bals[address] += round(value / 10**decimals, ROUND_DECIMALS)
+    bals[address] = round(bals[address], ROUND_DECIMALS)
 
 
 def subtract_from_bals(
@@ -155,9 +195,11 @@ def subtract_from_bals(
 ):
     if address not in bals:
         bals[address] = 0
-    bals[address] -= round(value / 10**decimals, 6)
-    # if bals[address] < 0:
-    #     bals[address] = 0
+    bals[address] -= round(value / 10**decimals, ROUND_DECIMALS)
+    # If the balance is negative, set it to 0. happens because of rounding errors.
+    if bals[address] < 0:
+        bals[address] = 0
+    bals[address] = round(bals[address], ROUND_DECIMALS)
 
 
 def get_silo_contract(chain: Chain, market: SiloFinanceMarket) -> Contract: