v2.23.0 - V3 Stakes, Submission Scores, Rounds

numerapi/base_api.py

@@ -383,6 +383,211 @@ def get_models(self, tournament: int | None = None) -> Dict:
         }
         return mapping
 
+    def v3_stake_auth(
+        self,
+        submission_id: str,
+        staker: str,
+        amount: float | str | None = None,
+        max_amount: float | str | None = None,
+    ) -> Dict:
+        """Issue a staking v3 authorization for a selected submission.
+
+        Args:
+            submission_id (str): submission id for the selected submission
+            staker (str): staker wallet address
+            amount (float or str, optional): max stake amount for the
+                authorization. Retained as a backwards-compatible alias for
+                `max_amount`.
+            max_amount (float or str, optional): max stake amount for the
+                authorization.
+
+        Returns:
+            dict: authorization payload with the following fields:
+
+                * authorizationSigner (`str`)
+                * authorizationDigest (`str`)
+                * chainId (`str`)
+                * deadline (`str`)
+                * maxAmount (`str`)
+                * amount (`str`) alias for `maxAmount`
+                * modelId (`str`)
+                * nmrAddress (`str`)
+                * nonce (`str`)
+                * roundId (`str`)
+                * signature (`str`)
+                * staker (`str`)
+                * stakingAddress (`str`)
+                * submissionId (`str`)
+                * submissionHash (`str`)
+                * tournamentId (`str`)
+        """
+        if (amount is None) == (max_amount is None):
+            raise ValueError("Provide exactly one of amount or max_amount.")
+
+        max_amount = max_amount if max_amount is not None else amount
+        query = """
+          mutation($submissionId: ID!, $staker: String!, $maxAmount: String!) {
+            v3StakeAuth(
+              submissionId: $submissionId
+              staker: $staker
+              maxAmount: $maxAmount
+            ) {
+              authorizationSigner
+              authorizationDigest
+              chainId
+              deadline
+              maxAmount
+              modelId
+              nmrAddress
+              nonce
+              roundId
+              signature
+              staker
+              stakingAddress
+              submissionId
+              submissionHash
+              tournamentId
+            }
+          }
+        """
+        arguments = {
+            "submissionId": submission_id,
+            "staker": staker,
+            "maxAmount": str(max_amount),
+        }
+        authorization = self.raw_query(query, arguments, authorization=True)["data"][
+            "v3StakeAuth"
+        ]
+        authorization["amount"] = authorization["maxAmount"]
+        return authorization
+
+    def v3_stake_config(self) -> Dict:
+        """Fetch staking v3 contract configuration.
+
+        Returns:
+            dict: staking v3 configuration with the following fields:
+
+                * address (`str`)
+                * authorizationSigner (`str`)
+                * nmrAddress (`str`)
+                * owner (`str`)
+                * paused (`bool`)
+                * pendingOwner (`str`)
+                * serviceWallet (`str`)
+        """
+        query = """
+          query {
+            v3StakeConfig {
+              address
+              authorizationSigner
+              nmrAddress
+              owner
+              paused
+              pendingOwner
+              serviceWallet
+            }
+          }
+        """
+        return self.raw_query(query, authorization=True)["data"]["v3StakeConfig"]
+
+    def v3_stake_round(self, round_id: int | str) -> Dict:
+        """Fetch staking v3 round status by round id.
+
+        Args:
+            round_id (int or str): round id
+
+        Returns:
+            dict: staking v3 round data with the following fields:
+
+                * closeTime (`str`)
+                * merkleRoot (`str`)
+                * openTime (`str`)
+                * payoutFactor (`str`)
+                * remainingBurn (`str`)
+                * remainingPayout (`str`)
+                * resolveTime (`str`)
+                * resolved (`bool`)
+                * roundId (`str`)
+                * stakeCap (`str`)
+                * stakeThreshold (`str`)
+                * state (`str`)
+                * totalPayout (`str`)
+                * totalStaked (`str`)
+                * tournamentId (`str`)
+        """
+        query = """
+          query($roundId: String!) {
+            v3StakeRound(roundId: $roundId) {
+              closeTime
+              merkleRoot
+              openTime
+              payoutFactor
+              remainingBurn
+              remainingPayout
+              resolveTime
+              resolved
+              roundId
+              stakeCap
+              stakeThreshold
+              state
+              totalPayout
+              totalStaked
+              tournamentId
+            }
+          }
+        """
+        arguments = {"roundId": str(round_id)}
+        return self.raw_query(query, arguments, authorization=True)["data"][
+            "v3StakeRound"
+        ]
+
+    def v3_stake_claim(self, round_id: int | str, model_id: str, staker: str) -> Dict:
+        """Fetch a staking v3 claim proof for a model and staker.
+
+        Args:
+            round_id (int or str): round id
+            model_id (str): model id
+            staker (str): staker wallet address
+
+        Returns:
+            dict: claim payload with the following fields:
+
+                * apiModelId (`str`)
+                * burnAmountWei (`str`)
+                * merkleRoot (`str`)
+                * modelId (`str`)
+                * payoutAmountWei (`str`)
+                * proof (`list` of `str`)
+                * roundId (`str`)
+                * staker (`str`)
+                * submissionId (`str`)
+                * tournamentId (`str`)
+        """
+        query = """
+          query($roundId: String!, $modelId: ID!, $staker: String!) {
+            v3StakeClaim(roundId: $roundId, modelId: $modelId, staker: $staker) {
+              apiModelId
+              burnAmountWei
+              merkleRoot
+              modelId
+              payoutAmountWei
+              proof
+              roundId
+              staker
+              submissionId
+              tournamentId
+            }
+          }
+        """
+        arguments = {
+            "roundId": str(round_id),
+            "modelId": model_id,
+            "staker": staker,
+        }
+        return self.raw_query(query, arguments, authorization=True)["data"][
+            "v3StakeClaim"
+        ]
+
     def get_current_round(self, tournament: int | None = None) -> int | None:
         """Get number of the current active round.
 
@@ -1200,7 +1405,7 @@ def check_new_round(self, hours: int = 12) -> bool:
             return False
         if raw is None:
             return False
-        open_time = utils.parse_datetime_string(raw['openTime'])
+        open_time = utils.parse_datetime_string(raw["openTime"])
         now = datetime.datetime.now(tz=pytz.utc)
         is_new_round = open_time > now - datetime.timedelta(hours=hours)
         return is_new_round

setup.py

@@ -5,7 +5,7 @@ def load(path):
     return open(path, "r").read()
 
 
-numerapi_version = "2.22.0"
+numerapi_version = "2.23.0.dev0"
 
 
 classifiers = [

tests/test_base_api.py

@@ -1,3 +1,4 @@
+import json
 import os
 import pytest
 import responses
@@ -116,3 +117,148 @@ def test_set_submission_webhook(api):
         'https://triggerurl'
     )
     assert res
+
+
+@responses.activate
+def test_v3_stake_auth(api):
+    api.token = ("", "")
+    data = {"data": {"v3StakeAuth": {
+        "authorizationSigner": "0xsigner",
+        "authorizationDigest": "0xdigest",
+        "chainId": "11155111",
+        "deadline": "1770000000",
+        "maxAmount": "25",
+        "modelId": "0xmodel",
+        "nmrAddress": "0xnmr",
+        "nonce": "0",
+        "roundId": "4321",
+        "signature": "0x1234",
+        "staker": "0xstaker",
+        "stakingAddress": "0xstaking",
+        "submissionId": "submission-id",
+        "submissionHash": "0xhash",
+        "tournamentId": "8",
+    }}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    result = api.v3_stake_auth("submission-id", "0xstaker", amount=25)
+
+    body = json.loads(responses.calls[0].request.body)
+    assert "v3StakeAuth" in body["query"]
+    assert body["variables"]["submissionId"] == "submission-id"
+    assert body["variables"]["maxAmount"] == "25"
+    assert "maxAmount" in body["query"]
+    assert result["maxAmount"] == "25"
+    assert result["amount"] == "25"
+    assert result["authorizationDigest"] == "0xdigest"
+
+
+@responses.activate
+def test_v3_stake_auth_accepts_max_amount(api):
+    api.token = ("", "")
+    data = {"data": {"v3StakeAuth": {
+        "authorizationSigner": "0xsigner",
+        "authorizationDigest": "0xdigest",
+        "chainId": "11155111",
+        "deadline": "1770000000",
+        "maxAmount": "30",
+        "modelId": "0xmodel",
+        "nmrAddress": "0xnmr",
+        "nonce": "0",
+        "roundId": "4321",
+        "signature": "0x1234",
+        "staker": "0xstaker",
+        "stakingAddress": "0xstaking",
+        "submissionId": "submission-id",
+        "submissionHash": "0xhash",
+        "tournamentId": "8",
+    }}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    result = api.v3_stake_auth(
+        "submission-id",
+        "0xstaker",
+        max_amount="30",
+    )
+
+    body = json.loads(responses.calls[0].request.body)
+    assert body["variables"]["maxAmount"] == "30"
+    assert result["maxAmount"] == "30"
+    assert result["amount"] == "30"
+
+
+@responses.activate
+def test_v3_stake_config(api):
+    api.token = ("", "")
+    data = {"data": {"v3StakeConfig": {
+        "address": "0xstaking",
+        "authorizationSigner": "0xsigner",
+        "nmrAddress": "0xnmr",
+        "owner": "0xowner",
+        "paused": False,
+        "pendingOwner": "0xpending",
+        "serviceWallet": "0xservice",
+    }}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    result = api.v3_stake_config()
+
+    body = json.loads(responses.calls[0].request.body)
+    assert "v3StakeConfig" in body["query"]
+    assert result["authorizationSigner"] == "0xsigner"
+
+
+@responses.activate
+def test_v3_stake_round(api):
+    api.token = ("", "")
+    data = {"data": {"v3StakeRound": {
+        "closeTime": "1",
+        "merkleRoot": "0xroot",
+        "openTime": "0",
+        "payoutFactor": "0.5",
+        "remainingBurn": "0",
+        "remainingPayout": "2",
+        "resolveTime": "2",
+        "resolved": False,
+        "roundId": "4321",
+        "stakeCap": "100",
+        "stakeThreshold": "10",
+        "state": "open",
+        "totalPayout": "2",
+        "totalStaked": "50",
+        "tournamentId": "8",
+    }}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    result = api.v3_stake_round(4321)
+
+    body = json.loads(responses.calls[0].request.body)
+    assert "v3StakeRound" in body["query"]
+    assert body["variables"]["roundId"] == "4321"
+    assert result["roundId"] == "4321"
+
+
+@responses.activate
+def test_v3_stake_claim(api):
+    api.token = ("", "")
+    data = {"data": {"v3StakeClaim": {
+        "apiModelId": "api-model-id",
+        "burnAmountWei": "0",
+        "merkleRoot": "0xroot",
+        "modelId": "0xmodel",
+        "payoutAmountWei": "2000000000000000000",
+        "proof": ["0xproof"],
+        "roundId": "4321",
+        "staker": "0xstaker",
+        "submissionId": "submission-id",
+        "tournamentId": "8",
+    }}}
+    responses.add(responses.POST, base_api.API_TOURNAMENT_URL, json=data)
+
+    result = api.v3_stake_claim(4321, "api-model-id", "0xstaker")
+
+    body = json.loads(responses.calls[0].request.body)
+    assert "v3StakeClaim" in body["query"]
+    assert body["variables"]["roundId"] == "4321"
+    assert body["variables"]["modelId"] == "api-model-id"
+    assert result["proof"] == ["0xproof"]

tests/test_numerapi.py

@@ -1,5 +1,6 @@
 import pytest
 import datetime
+import json
 import pytz
 import responses
 
@@ -99,3 +100,4 @@ def test_check_new_round(api):
     assert api.check_new_round()
     # second
     assert not api.check_new_round()
+