Hotfix/staking kpi reachability

packages/valory/skills/decision_maker_abci/behaviours/base.py

@@ -340,6 +340,21 @@ def check_balance(self) -> WaitableConditionType:
         self._report_balance()
         return True
 
+    def update_bet_transaction_information(self) -> None:
+        """Get whether the bet's invested amount should be updated."""
+        self.read_bets()
+        # Update the bet's invested amount, the new bet amount is added to previous invested amount
+        self.bets[
+            self.synchronized_data.sampled_bet_index
+        ].invested_amount += self.synchronized_data.bet_amount
+
+        # Update bet transaction timestamp
+        self.bets[
+            self.synchronized_data.sampled_bet_index
+        ].transaction_processed_timestamp = self.synced_timestamp
+        self.store_bets()
+        return
+
     def send_message(
         self, msg: Message, dialogue: Dialogue, callback: Callable
     ) -> None:

packages/valory/skills/decision_maker_abci/behaviours/reedem.py

@@ -53,6 +53,9 @@
     Trade,
 )
 from packages.valory.skills.decision_maker_abci.states.redeem import RedeemRound
+from packages.valory.skills.decision_maker_abci.states.bet_placement import (
+    BetPlacementRound,
+)
 from packages.valory.skills.market_manager_abci.graph_tooling.requests import (
     FetchStatus,
     MAX_LOG_SIZE,
@@ -966,6 +969,9 @@ def async_act(self) -> Generator:
             if not success:
                 return None
 
+            if self.synchronized_data.tx_submitter == BetPlacementRound.auto_round_id():
+                self.update_bet_transaction_information()
+
             payload: Optional[RedeemPayload]
             if self.benchmarking_mode.enabled:
                 payload = self._benchmarking_act()

packages/valory/skills/decision_maker_abci/behaviours/sampling.py

@@ -99,15 +99,49 @@ def processable_bet(self, bet: Bet) -> bool:
 
     def _sampled_bet_idx(self, bets: List[Bet]) -> int:
         """
-        Sample a bet and return its id.
-
-        The sampling logic is relatively simple at the moment.
-        It simply selects the unprocessed bet with the largest liquidity.
+        Sample a bet and return its index.
+
+        The sampling logic follows the specified priority logic:
+        1. Filter out all the bets that have a processed_timestamp != 0 to get a list of new bets.
+        2. If the list of new bets is not empty:
+           2.1 Order the list in decreasing order of liquidity (highest liquidity first).
+           2.2 For bets with the same liquidity, order them in decreasing order of market closing time (openingTimestamp).
+        3. If the list of new bets is empty:
+           3.1 Order the bets in decreasing order of invested_amount.
+           3.2 For bets with the same invested_amount, order them in increasing order of processed_timestamp (least recently processed first).
+           3.3 For bets with the same invested_amount and processed_timestamp, order them in decreasing order of liquidity.
+           3.4 For bets with the same invested_amount, processed_timestamp, and liquidity, order them in decreasing order of market closing time (openingTimestamp).
 
         :param bets: the bets' values to compare for the sampling.
-        :return: the id of the sampled bet, out of all the available bets, not only the given ones.
+        :return: the index of the sampled bet, out of all the available bets, not only the given ones.
         """
-        return self.bets.index(max(bets))
+
+        # Filter out all the best with the smallest queue number
+        least_queue_number = min([bet.queue_no for bet in bets])
+        priority_bets = [bet for bet in bets if bet.queue_no == least_queue_number]
+
+        # Filter out all the bets that have a processed_timestamp == 0
+        new_in_priority_bets = [bet for bet in bets if bet.processed_timestamp == 0]
+
+        if new_in_priority_bets:
+            # Order the list in Decreasing order of liquidity
+            new_in_priority_bets.sort(
+                key=lambda bet: (bet.scaledLiquidityMeasure, bet.openingTimestamp),
+                reverse=True,
+            )
+            return self.bets.index(new_in_priority_bets[0])
+        else:
+            # Order first in Decreasing order of invested_amount
+            priority_bets.sort(
+                key=lambda bet: (
+                    bet.invested_amount,
+                    -bet.processed_timestamp,  # Increasing order of processed_timestamp
+                    bet.scaledLiquidityMeasure,
+                    bet.openingTimestamp,
+                ),
+                reverse=True,
+            )
+            return self.bets.index(priority_bets[0])
 
     def _sample(self) -> Optional[int]:
         """Sample a bet, mark it as processed, and return its index."""

packages/valory/skills/market_manager_abci/behaviours.py

@@ -58,6 +58,7 @@ def __init__(self, **kwargs: Any) -> None:
         """Initialize `BetsManagerBehaviour`."""
         super().__init__(**kwargs)
         self.bets: List[Bet] = []
+        self.current_queue_number: int = 0
         self.bets_filepath: str = self.params.store_path / BETS_FILENAME
 
     def store_bets(self) -> None:
@@ -93,6 +94,7 @@ def read_bets(self) -> None:
             with open(self.bets_filepath, READ_MODE) as bets_file:
                 try:
                     self.bets = json.load(bets_file, cls=BetsDecoder)
+
                     return
                 except (JSONDecodeError, TypeError):
                     err = (
@@ -130,6 +132,7 @@ def _process_chunk(self, chunk: Optional[List[Dict[str, Any]]]) -> None:
             bet = Bet(**raw_bet, market=self._current_market)
             index = self.get_bet_idx(bet.id)
             if index is None:
+                bet.queue_no = self.current_queue_number
                 self.bets.append(bet)
             else:
                 self.bets[index].update_market_info(bet)
@@ -138,6 +141,12 @@ def _update_bets(
         self,
     ) -> Generator:
         """Fetch the questions from all the prediction markets and update the local copy of the bets."""
+
+        # Extract the last queue number from the bets
+        # This is used to determine the next queue number
+        if self.bets:
+            self.current_queue_number = max(bet.queue_no for bet in self.bets) + 1
+
         while True:
             can_proceed = self._prepare_fetching()
             if not can_proceed:
@@ -154,6 +163,11 @@ def _update_bets(
             if self.synced_time >= bet.openingTimestamp - self.params.opening_margin:
                 bet.blacklist_forever()
 
+        # Extract the last queue number from the bets
+        # This is used to determine the next queue number
+        if self.bets:
+            self.current_queue_number = max(bet.queue_no for bet in self.bets)
+
         # truncate the bets, otherwise logs get too big
         bets_str = str(self.bets)[:MAX_LOG_SIZE]
         self.context.logger.info(f"Updated bets: {bets_str}")

packages/valory/skills/market_manager_abci/bets.py

@@ -95,10 +95,13 @@ class Bet:
     prediction_response: PredictionResponse = dataclasses.field(
         default_factory=get_default_prediction_response
     )
+    invested_amount: float = 0.0
     position_liquidity: int = 0
     potential_net_profit: int = 0
     processed_timestamp: int = 0
+    transaction_processed_timestamp: int = 0
     n_bets: int = 0
+    queue_no: int = 0
 
     def __post_init__(self) -> None:
         """Post initialization to adjust the values."""