Issue10 - Detect and claim unclaimed profits

pdr_backend/models/predictoor_contract.py

@@ -1,4 +1,5 @@
 import time
+from typing import List
 
 from enforce_typing import enforce_types
 from eth_keys import KeyAPI
@@ -218,6 +219,20 @@ def get_agg_predval(self, timestamp):
             print(e)
             return None
 
+    def payout_multiple(self, slots: List[int], wait_for_receipt=True):
+        """Claims the payout for given slots"""
+        gasPrice = self.config.w3.eth.gas_price
+        try:
+            tx = self.contract_instance.functions.payoutMultiple(
+                slots, self.config.owner
+            ).transact({"from": self.config.owner, "gasPrice": gasPrice})
+            if not wait_for_receipt:
+                return tx
+            return self.config.w3.eth.wait_for_transaction_receipt(tx)
+        except Exception as e:
+            print(e)
+            return None
+
     def payout(self, slot, wait_for_receipt=False):
         """Claims the payout for a slot"""
         gasPrice = self.config.w3.eth.gas_price

pdr_backend/predictoor/approach1/main.py

@@ -70,7 +70,7 @@ def process_topic(address, timestamp):
         predictoor_contract.payout(slot, False)
 
     if seconds_till_epoch_end <= int(os.getenv("SECONDS_TILL_EPOCH_END", 60)):
-        """Timestamp of prediction"""
+        # Timestamp of prediction
         if do_prediction(topic, epoch, predictoor_contract):
             topics[address]["last_submited_epoch"] = epoch
 
@@ -87,7 +87,7 @@ def do_prediction(topic, epoch, predictoor_contract):
         )
         return False
 
-    """We have a prediction, let's submit it"""
+    # We have a prediction, let's submit it
     stake_amount = (
         os.getenv("STAKE_AMOUNT", 1) * predicted_confidence / 100
     )  # TODO have a customizable function to handle this

pdr_backend/predictoor/payout.py

@@ -0,0 +1,23 @@
+from typing import List
+
+from pdr_backend.models.predictoor_contract import PredictoorContract
+from pdr_backend.util.subgraph import query_pending_payouts
+
+
+def request_payout(predictoor_contract: PredictoorContract, timestamps: List[int]):
+    predictoor_contract.payout_multiple(timestamps, True)
+
+
+def batchify(data, batch_size):
+    return [data[i : i + batch_size] for i in range(0, len(data), batch_size)]
+
+
+def claim_pending_payouts(
+    subgraph_url: str, predictoor_contract: PredictoorContract, batch_size: int
+):
+    addr = predictoor_contract.config.owner
+    pending = query_pending_payouts(subgraph_url, addr)
+    batches = batchify(pending, batch_size)
+
+    for batch in batches:
+        request_payout(predictoor_contract, batch)

pdr_backend/util/subgraph.py

@@ -56,6 +56,7 @@
 """
 
 import os
+import requests
 from typing import Optional, Dict, List
 
 import requests
@@ -135,6 +136,40 @@ def query_subgraph(subgraph_url: str, query: str) -> Dict[str, dict]:
     return result
 
 
+def query_pending_payouts(subgraph_url: str, addr: str) -> List[int]:
+    chunk_size = 1000
+    offset = 0
+    timestamps: List[int] = []
+
+    while True:
+        query = """
+        {
+                predictPredictions(
+                    where: {user: "%s", payout: null}
+                ) {
+                    id
+                    timestamp
+                }
+        }
+        """ % (
+            addr
+        )
+
+        offset += chunk_size
+        try:
+            result = query_subgraph(subgraph_url, query)
+            if not "data" in result:
+                print("No data in result")
+                break
+            predict_predictions = result["data"]["predictPredictions"]
+            timestamps_query = [i["timestamp"] for i in predict_predictions]
+            timestamps.extend(timestamps_query)
+        except Exception as e:
+            print("An error occured", e)
+
+    return timestamps
+
+
 @enforce_types
 def query_predictContracts(  # pylint: disable=too-many-statements
     subgraph_url: str,