git merge main

pdr_backend/conftest_ganache.py

@@ -1,8 +1,8 @@
 import os
-
 import pytest
 
 from pdr_backend.models.token import Token
+from pdr_backend.models.predictoor_batcher import PredictoorBatcher
 from pdr_backend.models.predictoor_contract import PredictoorContract
 from pdr_backend.publisher.publish import publish
 from pdr_backend.util.contract import get_address
@@ -82,3 +82,30 @@ def predictoor_contract():
     )
     dt_addr = logs["newTokenAddress"]
     return PredictoorContract(config, dt_addr)
+
+
+@pytest.fixture(scope="module")
+def predictoor_contract2():
+    config = Web3Config(_rpc_url(), _private_key())
+    _, _, _, _, logs = publish(
+        s_per_epoch=SECONDS_PER_EPOCH,
+        s_per_subscription=SECONDS_PER_EPOCH * 24,
+        base="ETH",
+        quote="USDT",
+        source="kraken",
+        timeframe="5m",
+        trueval_submitter_addr=config.owner,
+        feeCollector_addr=config.owner,
+        rate=3,
+        cut=0.2,
+        web3_config=config,
+    )
+    dt_addr = logs["newTokenAddress"]
+    return PredictoorContract(config, dt_addr)
+
+
+# pylint: disable=redefined-outer-name
+@pytest.fixture(scope="module")
+def predictoor_batcher():
+    predictoor_batcher_addr = get_address(_chain_id(), "PredictoorHelper")
+    return PredictoorBatcher(_web3_config(), predictoor_batcher_addr)

pdr_backend/dfbuyer/main.py

@@ -7,7 +7,7 @@
 from pdr_backend.dfbuyer.subgraph import get_consume_so_far
 from pdr_backend.models.predictoor_contract import PredictoorContract
 from pdr_backend.util.env import getenv_or_exit
-from pdr_backend.util.subgraph import query_predictContracts
+from pdr_backend.util.subgraph import query_feed_contracts
 from pdr_backend.util.web3_config import Web3Config
 
 rpc_url = getenv_or_exit("RPC_URL")
@@ -65,7 +65,7 @@ def process_block(block):
     """Process each contract and see if we need to submit"""
     global topics
     if not topics:
-        topics = query_predictContracts(
+        topics = query_feed_contracts(
             subgraph_url,
             pair_filters,
             timeframe_filter,

pdr_backend/models/base_config.py

@@ -2,10 +2,11 @@
 
 from enforce_typing import enforce_types
 
+from pdr_backend.models.feed import dictToFeed, Feed
 from pdr_backend.models.predictoor_contract import PredictoorContract
 from pdr_backend.models.slot import Slot
 from pdr_backend.util.env import getenv_or_exit, parse_filters
-from pdr_backend.util.subgraph import get_pending_slots, query_predictContracts
+from pdr_backend.util.subgraph import get_pending_slots, query_feed_contracts
 from pdr_backend.util.web3_config import Web3Config
 
 
@@ -35,16 +36,17 @@ def get_pending_slots(self, timestamp: int) -> List[Slot]:
             self.source_filter,
         )
 
-    def get_feeds(self) -> Dict[str, dict]:
+    def get_feeds(self) -> Dict[str, Feed]:
         """Return dict of [feed_addr] : {"name":.., "pair":.., ..}"""
-        feeds_dict = query_predictContracts(
+        feed_dicts = query_feed_contracts(
             self.subgraph_url,
             self.pair_filters,
             self.timeframe_filter,
             self.source_filter,
             self.owner_addresses,
         )
-        return feeds_dict
+        feeds = {addr: dictToFeed(feed_dict) for addr, feed_dict in feed_dicts.items()}
+        return feeds
 
     def get_contracts(self, feed_addrs: List[str]) -> Dict[str, PredictoorContract]:
         """Return dict of [feed_addr] : PredictoorContract}"""

pdr_backend/models/data_nft.py

@@ -1,8 +1,11 @@
+from typing import Union
+
 import hashlib
 import json
 
 from enforce_typing import enforce_types
 from web3 import Web3
+from web3.types import TxReceipt, HexBytes
 
 from pdr_backend.util.web3_config import Web3Config
 from pdr_backend.util.contract import get_contract_abi
@@ -67,3 +70,14 @@ def set_ddo(self, ddo, wait_for_receipt=True):
         if wait_for_receipt:
             self.config.w3.eth.wait_for_transaction_receipt(tx)
         return tx
+
+    def add_to_create_erc20_list(
+        self, addr: str, wait_for_receipt=True
+    ) -> Union[HexBytes, TxReceipt]:
+        gasPrice = self.config.w3.eth.gas_price
+        tx = self.contract_instance.functions.addToCreateERC20List(addr).transact(
+            {"from": self.config.owner, "gasPrice": gasPrice}
+        )
+        if not wait_for_receipt:
+            return tx
+        return self.config.w3.eth.wait_for_transaction_receipt(tx)

pdr_backend/models/feed.py

@@ -1,4 +1,10 @@
+from typing import Any, Dict
+
+from enforce_typing import enforce_types
+
+
 class Feed:  # pylint: disable=too-many-instance-attributes
+    @enforce_types
     def __init__(
         self,
         name: str,
@@ -30,3 +36,31 @@ def quote(self):
     @property
     def base(self):
         return self.pair.split("-")[0]
+
+
+@enforce_types
+def dictToFeed(feed_dict: Dict[str, Any]):
+    """
+    @description
+      Convert a feed_dict into Feed format
+
+    @arguments
+      feed_dict -- dict with values for "name", "address", etc
+
+    @return
+      feed -- Feed
+    """
+    d = feed_dict
+    feed = Feed(
+        name=d["name"],
+        address=d["address"],
+        symbol=d["symbol"],
+        seconds_per_epoch=d["seconds_per_epoch"],
+        seconds_per_subscription=d["seconds_per_subscription"],
+        trueval_submit_timeout=d["trueval_submit_timeout"],
+        owner=d["owner"],
+        pair=d["pair"],
+        timeframe=d["timeframe"],
+        source=d["source"],
+    )
+    return feed

pdr_backend/models/predictoor_batcher.py

@@ -0,0 +1,64 @@
+from typing import List
+from enforce_typing import enforce_types
+from eth_typing import ChecksumAddress
+from pdr_backend.util.contract import get_contract_abi
+from pdr_backend.util.web3_config import Web3Config
+
+
+@enforce_types
+class PredictoorBatcher:
+    def __init__(self, config: Web3Config, address: str):
+        self.config = config
+        self.contract_address = config.w3.to_checksum_address(address)
+        self.contract_instance = config.w3.eth.contract(
+            address=config.w3.to_checksum_address(address),
+            abi=get_contract_abi("PredictoorHelper"),
+        )
+        self.contract_address = config.w3.to_checksum_address(address)
+
+    def consume_multiple(
+        self,
+        addresses: List[ChecksumAddress],
+        times: List[int],
+        token_addr: str,
+        wait_for_receipt=True,
+    ):
+        gasPrice = self.config.w3.eth.gas_price
+        tx = self.contract_instance.functions.consumeMultiple(
+            addresses, times, token_addr
+        ).transact({"from": self.config.owner, "gasPrice": gasPrice})
+        if not wait_for_receipt:
+            return tx
+        return self.config.w3.eth.wait_for_transaction_receipt(tx)
+
+    def submit_truevals_contracts(
+        self,
+        contract_addrs: List[ChecksumAddress],
+        epoch_starts: List[List[int]],
+        trueVals: List[List[bool]],
+        cancelRounds: List[List[bool]],
+        wait_for_receipt=True,
+    ):
+        gasPrice = self.config.w3.eth.gas_price
+        tx = self.contract_instance.functions.submitTruevalContracts(
+            contract_addrs, epoch_starts, trueVals, cancelRounds
+        ).transact({"from": self.config.owner, "gasPrice": gasPrice})
+        if not wait_for_receipt:
+            return tx
+        return self.config.w3.eth.wait_for_transaction_receipt(tx)
+
+    def submit_truevals(
+        self,
+        contract_addr: ChecksumAddress,
+        epoch_starts: List[int],
+        trueVals: List[bool],
+        cancelRounds: List[bool],
+        wait_for_receipt=True,
+    ):
+        gasPrice = self.config.w3.eth.gas_price
+        tx = self.contract_instance.functions.submitTruevals(
+            contract_addr, epoch_starts, trueVals, cancelRounds
+        ).transact({"from": self.config.owner, "gasPrice": gasPrice})
+        if not wait_for_receipt:
+            return tx
+        return self.config.w3.eth.wait_for_transaction_receipt(tx)

pdr_backend/models/predictoor_contract.py

@@ -173,10 +173,10 @@ def get_exchanges(self):
     def get_stake_token(self):
         return self.contract_instance.functions.stakeToken().call()
 
-    def get_price(self):
+    def get_price(self) -> int:
         fixed_rates = self.get_exchanges()
         if not fixed_rates:
-            return None
+            return 0
         (fixed_rate_address, exchange_id) = fixed_rates[0]
         # get datatoken price
         exchange = FixedRate(self.config, fixed_rate_address)
@@ -361,3 +361,6 @@ def redeem_unused_slot_revenue(self, timestamp, wait_for_receipt=True):
 
     def get_block(self, block):
         return self.config.w3.eth.get_block(block)
+
+    def erc721_addr(self) -> str:
+        return self.contract_instance.functions.getERC721Address().call()

pdr_backend/models/test/test_base_config.py

@@ -4,9 +4,23 @@
 
 from pdr_backend.models.base_config import BaseConfig
 
-ADDR = "0xe8933f2950aec1080efad1ca160a6bb641ad245d"  # predictoor contract addr
 PRIV_KEY = "0xef4b441145c1d0f3b4bc6d61d29f5c6e502359481152f869247c7a4244d45209"
 
+ADDR = "0xe8933f2950aec1080efad1ca160a6bb641ad245d"  # predictoor contract addr
+
+FEED_DICT = {  # info inside a predictoor contract
+    "name": "Contract Name",
+    "address": ADDR,
+    "symbol": "test",
+    "seconds_per_epoch": 300,
+    "seconds_per_subscription": 60,
+    "trueval_submit_timeout": 15,
+    "owner": "0xowner",
+    "pair": "BTC-ETH",
+    "timeframe": "1h",
+    "source": "binance",
+}
+
 
 @enforce_types
 def test_base_config_with_filters(monkeypatch):
@@ -58,15 +72,13 @@ def test_base_config_feeds_contracts(monkeypatch):
     c = BaseConfig()
 
     # test get_feeds()
-    def _mock_query_predictContracts(
-        *args, **kwargs
-    ):  # pylint: disable=unused-argument
-        feeds_dict = {ADDR: "a mock_contract"}
-        return feeds_dict
+    def _mock_query_feed_contracts(*args, **kwargs):  # pylint: disable=unused-argument
+        feed_dicts = {ADDR: FEED_DICT}
+        return feed_dicts
 
     with patch(
-        "pdr_backend.models.base_config.query_predictContracts",
-        _mock_query_predictContracts,
+        "pdr_backend.models.base_config.query_feed_contracts",
+        _mock_query_feed_contracts,
     ):
         feeds = c.get_feeds()
     feed_addrs = list(feeds.keys())

pdr_backend/models/test/test_feed.py

@@ -1,7 +1,10 @@
-from pdr_backend.models.feed import Feed
+from enforce_typing import enforce_types
 
+from pdr_backend.models.feed import dictToFeed, Feed
 
-def test_contract_data_initialization():
+
+@enforce_types
+def test_feed1():
     feed = Feed(
         "Contract Name",
         "0x12345",
@@ -27,3 +30,34 @@ def test_contract_data_initialization():
     assert feed.source == "binance"
     assert feed.quote == "ETH"
     assert feed.base == "BTC"
+
+
+@enforce_types
+def test_feed2():
+    feed_dict = {
+        "name": "Contract Name",
+        "address": "0x12345",
+        "symbol": "test",
+        "seconds_per_epoch": 300,
+        "seconds_per_subscription": 60,
+        "trueval_submit_timeout": 15,
+        "owner": "0xowner",
+        "pair": "BTC-ETH",
+        "timeframe": "1h",
+        "source": "binance",
+    }
+    feed = dictToFeed(feed_dict)
+    assert isinstance(feed, Feed)
+
+    assert feed.name == "Contract Name"
+    assert feed.address == "0x12345"
+    assert feed.symbol == "test"
+    assert feed.seconds_per_epoch == 300
+    assert feed.seconds_per_subscription == 60
+    assert feed.trueval_submit_timeout == 15
+    assert feed.owner == "0xowner"
+    assert feed.pair == "BTC-ETH"
+    assert feed.timeframe == "1h"
+    assert feed.source == "binance"
+    assert feed.quote == "ETH"
+    assert feed.base == "BTC"