Feat/sell

packages/valory/contracts/market_maker/contract.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 # ------------------------------------------------------------------------------
 #
-#   Copyright 2023 Valory AG
+#   Copyright 2024 Valory AG
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
@@ -133,3 +133,54 @@ def get_buy_data(
             outcomeIndex=outcome_index,
             minOutcomeTokensToBuy=min_outcome_tokens_to_buy,
         )
+
+    @classmethod
+    def calc_sell_amount(
+        cls,
+        ledger_api: EthereumApi,
+        contract_address: str,
+        return_amount: int,
+        outcome_index: int,
+    ) -> JSONLike:
+        """
+        Calculate the buy amount.
+
+        :param ledger_api: the ledger API object
+        :param contract_address: the contract address
+        :param return_amount: the amount the user will have returned
+        :param outcome_index: the index of the answer's outcome that the user wants to sell for
+        :return: the outcomeTokenSellAmount
+        """
+        outcome_token_sell_amount = cls._method_call(
+            ledger_api,
+            contract_address,
+            "calcSellAmount",
+            returnAmount=return_amount,
+            outcomeIndex=outcome_index,
+        )
+        return dict(outcomeTokenSellAmount=outcome_token_sell_amount)
+
+    def get_sell_data(
+        cls,
+        ledger_api: LedgerApi,
+        contract_address: str,
+        return_amount: int,
+        outcome_index: int,
+        max_outcome_tokens_to_sell: int,
+    ) -> Dict[str, bytes]:
+        """Gets the encoded arguments for a sell tx, which should only be called via the multisig.
+
+        :param ledger_api: the ledger API object
+        :param contract_address: the contract address
+        :param return_amount: the amount the user have returned
+        :param outcome_index: the index of the answer's outcome that the user wants to sell tokens for
+        :param max_outcome_tokens_to_sell: the output of the `calcSellAmount` contract method
+        """
+        return cls._encode_abi(
+            ledger_api,
+            contract_address,
+            "sell",
+            returnAmount=return_amount,
+            outcomeIndex=outcome_index,
+            maxOutcomeTokenSellAmount=max_outcome_tokens_to_sell,
+        )

packages/valory/contracts/market_maker/contract.yaml

@@ -9,7 +9,7 @@ fingerprint:
   README.md: bafybeiegnihrovfkk5big52pl4bo6evt5toqvvmft2jgnq6ofdbhfp7xwa
   __init__.py: bafybeicoucixii3fv5xlpk3zfewm4ys4okidcng54bhtjxvwup7g2jcjza
   build/FixedProductMarketMaker.json: bafybeigim7n3f67r5czfc5wp2m7cxzxwvnhxops3n5j2zlawenan7qrrtu
-  contract.py: bafybeicfiicuke4ly5hpcxtyvnob5bgzrqsopuxalruxp2m3w4koxmhrqa
+  contract.py: bafybeifcopgnnts3dbfh636vvdsgporlkt2olwr2iwuwaom5vjcrtbe5wi
 fingerprint_ignore_patterns: []
 contracts: []
 class_name: FixedProductMarketMakerContract

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

@@ -29,6 +29,7 @@
 from aea.configurations.data_types import PublicId
 from aea.protocols.base import Message
 from aea.protocols.dialogue.base import Dialogue
+from hexbytes import HexBytes
 
 from packages.valory.contracts.erc20.contract import ERC20
 from packages.valory.contracts.gnosis_safe.contract import (
@@ -724,6 +725,35 @@ def finish_behaviour(self, payload: BaseTxPayload) -> Generator:
 
         self.set_done()
 
+    def build_approval_tx(
+        self, amount: int, market_maker_contract_address: str, to_address: str
+    ) -> WaitableConditionType:
+        """Build an ERC20 approve transaction."""
+        response_msg = yield from self.get_contract_api_response(
+            performative=ContractApiMessage.Performative.GET_STATE,  # type: ignore
+            contract_address=self.collateral_token,
+            contract_id=str(ERC20.contract_id),
+            contract_callable="build_approval_tx",
+            spender=market_maker_contract_address,
+            amount=amount,
+        )
+
+        if response_msg.performative != ContractApiMessage.Performative.STATE:
+            self.context.logger.info(f"Could not build approval tx: {response_msg}")
+            return False
+
+        approval_data = response_msg.state.body.get("data")
+        if approval_data is None:
+            self.context.logger.info(f"Could not build approval tx: {response_msg}")
+            return False
+
+        batch = MultisendBatch(
+            to=to_address,
+            data=HexBytes(approval_data),
+        )
+        self.multisend_batches.append(batch)
+        return True
+
 
 class BaseSubscriptionBehaviour(DecisionMakerBaseBehaviour, ABC):
     """Base class for subscription behaviours."""

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

@@ -99,30 +99,12 @@ def _build_exchange_tx(self) -> WaitableConditionType:
 
     def _build_approval_tx(self) -> WaitableConditionType:
         """Build an ERC20 approve transaction."""
-        response_msg = yield from self.get_contract_api_response(
-            performative=ContractApiMessage.Performative.GET_STATE,  # type: ignore
-            contract_address=self.collateral_token,
-            contract_id=str(ERC20.contract_id),
-            contract_callable="build_approval_tx",
-            spender=self.market_maker_contract_address,
-            amount=self.investment_amount,
+        approval_tx = yield from self.build_approval_tx(
+            self.investment_amount,
+            self.market_maker_contract_address,
+            self.collateral_token,
         )
-
-        if response_msg.performative != ContractApiMessage.Performative.STATE:
-            self.context.logger.info(f"Could not build approval tx: {response_msg}")
-            return False
-
-        approval_data = response_msg.state.body.get("data")
-        if approval_data is None:
-            self.context.logger.info(f"Could not build approval tx: {response_msg}")
-            return False
-
-        batch = MultisendBatch(
-            to=self.collateral_token,
-            data=HexBytes(approval_data),
-        )
-        self.multisend_batches.append(batch)
-        return True
+        return approval_tx
 
     def _calc_buy_amount(self) -> WaitableConditionType:
         """Calculate the buy amount of the conditional token."""

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

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2024 Valory AG
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+# ------------------------------------------------------------------------------
+
+
+"""This module contains the behaviour for selling a token."""
+from typing import Any, Generator, Optional, cast
+
+from hexbytes import HexBytes
+
+from packages.valory.contracts.market_maker.contract import (
+    FixedProductMarketMakerContract,
+)
+from packages.valory.protocols.contract_api import ContractApiMessage
+from packages.valory.skills.decision_maker_abci.behaviours.base import (
+    DecisionMakerBaseBehaviour,
+    WaitableConditionType,
+)
+from packages.valory.skills.decision_maker_abci.models import MultisendBatch
+from packages.valory.skills.decision_maker_abci.payloads import MultisigTxPayload
+from packages.valory.skills.decision_maker_abci.states.sell_outcome_token import (
+    SellOutcomeTokenRound,
+)
+
+
+class SellTokenBehaviour(DecisionMakerBaseBehaviour):
+    """A behaviour in which the agents sell a token."""
+
+    matching_round = SellOutcomeTokenRound
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize the sell token behaviour."""
+        super().__init__(**kwargs)
+        self.sell_amount: float = 0.0
+        self.return_amount: int = 0
+
+    @property
+    def market_maker_contract_address(self) -> str:
+        """Get the contract address of the market maker on which the service is going to place the bet."""
+        return self.sampled_bet.id
+
+    @property
+    def outcome_index(self) -> int:
+        """Get the index of the outcome for which the service is going to sell token."""
+        return cast(int, self.synchronized_data.vote)
+
+    def _build_approval_tx(self) -> WaitableConditionType:
+        """Build an ERC20 approve transaction."""
+        approval_tx = yield from self.build_approval_tx(
+            self.return_amount,
+            self.market_maker_contract_address,
+            self.market_maker_contract_address,
+        )
+        return approval_tx
+
+    def _calc_sell_amount(self) -> WaitableConditionType:
+        """Calculate the sell amount of the conditional token."""
+        response_msg = yield from self.get_contract_api_response(
+            performative=ContractApiMessage.Performative.GET_RAW_TRANSACTION,  # type: ignore
+            contract_address=self.market_maker_contract_address,
+            contract_id=str(FixedProductMarketMakerContract.contract_id),
+            contract_callable="calc_sell_amount",
+            return_amount=self.return_amount,
+            outcome_index=self.outcome_index,
+        )
+        if response_msg.performative != ContractApiMessage.Performative.RAW_TRANSACTION:
+            self.context.logger.error(
+                f"Could not calculate the sell amount: {response_msg}"
+            )
+            return False
+
+        sell_amount = response_msg.raw_transaction.body.get(
+            "outcomeTokenSellAmount", None
+        )
+        if sell_amount is None:
+            self.context.logger.error(
+                f"Something went wrong while trying to get the outcomeTokenSellAmount amount for the conditional token: {response_msg}"
+            )
+            return False
+
+        self.sell_amount = sell_amount
+        return True
+
+    def _build_sell_tx(self) -> WaitableConditionType:
+        """Get the sell tx data encoded."""
+        response_msg = yield from self.get_contract_api_response(
+            performative=ContractApiMessage.Performative.GET_STATE,  # type: ignore
+            contract_address=self.market_maker_contract_address,
+            contract_id=str(FixedProductMarketMakerContract.contract_id),
+            contract_callable="get_sell_data",
+            return_amount=self.return_amount,
+            outcome_index=self.outcome_index,
+            max_outcome_tokens_to_sell=self.sell_amount,
+        )
+        if response_msg.performative != ContractApiMessage.Performative.STATE:
+            self.context.logger.error(
+                f"Could not get the data for the buy transaction: {response_msg}"
+            )
+            return False
+
+        sell_data = response_msg.state.body.get("data", None)
+        if sell_data is None:
+            self.context.logger.error(
+                f"Something went wrong while trying to encode the buy data: {response_msg}"
+            )
+            return False
+
+        batch = MultisendBatch(
+            to=self.market_maker_contract_address,
+            data=HexBytes(sell_data),
+        )
+        self.multisend_batches.append(batch)
+        return True
+
+    def _prepare_safe_tx(self) -> Generator[None, None, Optional[str]]:
+        """Prepare the safe transaction for selling an outcome token and return the hex for the tx settlement skill."""
+        for step in (
+            self._build_approval_tx,
+            self._calc_sell_amount,
+            self._build_sell_tx,
+            self._build_multisend_data,
+            self._build_multisend_safe_tx_hash,
+        ):
+            yield from self.wait_for_condition_with_sleep(step)
+
+        outcome = self.sampled_bet.get_outcome(self.outcome_index)
+        investment = self._collateral_amount_info(self.return_amount)
+        self.context.logger.info(
+            f"Preparing a multisig transaction to sell the outcome token for {outcome!r}, with confidence "
+            f"{self.synchronized_data.confidence!r}, for the amount of {investment}, which is equal to the amount of "
+            f"{self.sell_amount!r} WEI of the conditional token corresponding to {outcome!r}."
+        )
+
+        return self.tx_hex
+
+    def async_act(self) -> Generator:
+        """Do the action."""
+
+        agent = self.context.agent_address
+
+        with self.context.benchmark_tool.measure(self.behaviour_id).local():
+            tx_submitter = betting_tx_hex = mocking_mode = None
+
+            # if the vote is the same as the previous vote then there is no change in the supported outcome, so we
+            # should not sell
+            if self.synchronized_data.vote == self.synchronized_data.previous_vote:
+                payload = MultisigTxPayload(
+                    agent, tx_submitter, betting_tx_hex, mocking_mode
+                )
+
+                yield from self.finish_behaviour(payload)
+
+            self.return_amount = self.bets[
+                self.synchronized_data.sampled_bet_index
+            ].invested_amount
+
+            if self.is_wxdai:
+                tx_submitter = self.matching_round.auto_round_id()
+                betting_tx_hex = yield from self._prepare_safe_tx()
+
+            payload = MultisigTxPayload(
+                agent, tx_submitter, betting_tx_hex, mocking_mode
+            )
+
+        yield from self.finish_behaviour(payload)

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

@@ -152,6 +152,12 @@ def vote(self) -> Optional[int]:
         vote = self.db.get_strict("vote")
         return int(vote) if vote is not None else None
 
+    @property
+    def previous_vote(self) -> Optional[int]:
+        """Get the bet's previous vote index."""
+        previous_vote = self.db.get_strict("previous_vote")
+        return int(previous_vote) if previous_vote is not None else None
+
     @property
     def confidence(self) -> float:
         """Get the vote's confidence."""

packages/valory/skills/decision_maker_abci/states/decision_receive.py

@@ -54,6 +54,12 @@ class DecisionReceiveRound(CollectSameUntilThresholdRound):
 
     def end_block(self) -> Optional[Tuple[SynchronizedData, Enum]]:
         """Process the end of the block."""
+
+        # update the previous vote before calling the super method
+        SynchronizedData.update(
+            previous_vote=SynchronizedData.vote
+        )
+
         res = super().end_block()
         if res is None:
             return None

packages/valory/skills/decision_maker_abci/states/sell_outcome_token.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2021-2024 Valory AG
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+# ------------------------------------------------------------------------------
+
+
+"""This module contains the sell outcome token state of the decision-making abci app."""
+
+from packages.valory.skills.decision_maker_abci.states.base import TxPreparationRound
+
+
+class SellOutcomeTokenRound(TxPreparationRound):
+    """A round for selling a token."""

packages/valory/skills/market_manager_abci/bets.py

@@ -107,7 +107,7 @@ class Bet:
     prediction_response: PredictionResponse = dataclasses.field(
         default_factory=get_default_prediction_response
     )
-    invested_amount: float = 0.0
+    invested_amount: int = 0
     position_liquidity: int = 0
     potential_net_profit: int = 0
     processed_timestamp: int = 0