olas-operate-middleware 0.6.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

operate/bridge/providers/relay_provider.py

@@ -0,0 +1,442 @@
+#!/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.
+#
+# ------------------------------------------------------------------------------
+"""Relay provider."""
+
+
+import enum
+import json
+import math
+import time
+import typing as t
+from http import HTTPStatus
+from urllib.parse import urlencode
+
+import requests
+
+from operate.bridge.providers.provider import (
+    DEFAULT_MAX_QUOTE_RETRIES,
+    MESSAGE_EXECUTION_FAILED,
+    MESSAGE_QUOTE_ZERO,
+    Provider,
+    ProviderRequest,
+    ProviderRequestStatus,
+    QuoteData,
+)
+from operate.operate_types import Chain
+
+
+GAS_ESTIMATE_FALLBACK_ADDRESS = "0x000000000000000000000000000000000000dEaD"
+
+# The following constants were determined empirically (+ margin) from the Relay API/Dapp.
+RELAY_DEFAULT_GAS = {
+    Chain.ETHEREUM: {
+        "deposit": 50_000,
+        "approve": 200_000,
+        "authorize": 1,
+        "authorize1": 1,
+        "authorize2": 1,
+        "swap": 400_000,
+        "send": 1,
+    },
+    Chain.BASE: {
+        "deposit": 50_000,
+        "approve": 200_000,
+        "authorize": 1,
+        "authorize1": 1,
+        "authorize2": 1,
+        "swap": 400_000,
+        "send": 1,
+    },
+    Chain.CELO: {
+        "deposit": 50_000,
+        "approve": 200_000,
+        "authorize": 1,
+        "authorize1": 1,
+        "authorize2": 1,
+        "swap": 400_000,
+        "send": 1,
+    },
+    Chain.GNOSIS: {
+        "deposit": 350_000,
+        "approve": 200_000,
+        "authorize": 1,
+        "authorize1": 1,
+        "authorize2": 1,
+        "swap": 500_000,
+        "send": 1,
+    },
+    Chain.MODE: {
+        "deposit": 50_000,
+        "approve": 200_000,
+        "authorize": 1,
+        "authorize1": 1,
+        "authorize2": 1,
+        "swap": 1_500_000,
+        "send": 1,
+    },
+    Chain.OPTIMISTIC: {
+        "deposit": 50_000,
+        "approve": 200_000,
+        "authorize": 1,
+        "authorize1": 1,
+        "authorize2": 1,
+        "swap": 400_000,
+        "send": 1,
+    },
+}
+
+
+class RelayExecutionStatus(str, enum.Enum):
+    """Relay execution status."""
+
+    REFUND = "refund"
+    DELAYED = "delayed"
+    WAITING = "waiting"
+    FAILURE = "failure"
+    PENDING = "pending"
+    SUCCESS = "success"
+
+    def __str__(self) -> str:
+        """__str__"""
+        return self.value
+
+
+class RelayProvider(Provider):
+    """Relay provider."""
+
+    def description(self) -> str:
+        """Get a human-readable description of the provider."""
+        return "Relay Protocol https://www.relay.link/"
+
+    def quote(self, provider_request: ProviderRequest) -> None:
+        """Update the request with the quote."""
+        self._validate(provider_request)
+
+        if provider_request.status not in (
+            ProviderRequestStatus.CREATED,
+            ProviderRequestStatus.QUOTE_DONE,
+            ProviderRequestStatus.QUOTE_FAILED,
+        ):
+            raise RuntimeError(
+                f"Cannot quote request {provider_request.id} with status {provider_request.status}."
+            )
+
+        if provider_request.execution_data:
+            raise RuntimeError(
+                f"Cannot quote request {provider_request.id}: execution already present."
+            )
+
+        from_chain = provider_request.params["from"]["chain"]
+        from_address = provider_request.params["from"]["address"]
+        from_token = provider_request.params["from"]["token"]
+        to_chain = provider_request.params["to"]["chain"]
+        to_address = provider_request.params["to"]["address"]
+        to_token = provider_request.params["to"]["token"]
+        to_amount = provider_request.params["to"]["amount"]
+
+        if to_amount == 0:
+            self.logger.info(f"[RELAY PROVIDER] {MESSAGE_QUOTE_ZERO}")
+            quote_data = QuoteData(
+                eta=0,
+                elapsed_time=0,
+                message=MESSAGE_QUOTE_ZERO,
+                provider_data=None,
+                timestamp=int(time.time()),
+            )
+            provider_request.quote_data = quote_data
+            provider_request.status = ProviderRequestStatus.QUOTE_DONE
+            return
+
+        url = "https://api.relay.link/quote"
+        headers = {"Content-Type": "application/json"}
+        payload = {
+            "originChainId": Chain(from_chain).id,
+            "user": from_address,
+            "originCurrency": from_token,
+            "destinationChainId": Chain(to_chain).id,
+            "recipient": to_address,
+            "destinationCurrency": to_token,
+            "amount": to_amount,
+            "tradeType": "EXACT_OUTPUT",
+            "enableTrueExactOutput": False,
+        }
+        for attempt in range(1, DEFAULT_MAX_QUOTE_RETRIES + 1):
+            start = time.time()
+            try:
+                self.logger.info(f"[RELAY PROVIDER] POST {url}")
+                self.logger.info(
+                    f"[RELAY PROVIDER] BODY {json.dumps(payload, indent=2, sort_keys=True)}"
+                )
+                response = requests.post(
+                    url=url, headers=headers, json=payload, timeout=30
+                )
+                response.raise_for_status()
+                response_json = response.json()
+
+                # Gas will be returned as 0 (unable to estimate) by the API endpoint when simulation fails.
+                # This happens when 'from_address'
+                #   * does not have enough funds/ERC20,
+                #   * requires to approve an ERC20 before another transaction.
+                # Call the API again using the default 'from_address' placeholder used by Relay DApp.
+                gas_missing = any(
+                    "gas" not in item.get("data", {})
+                    for step in response_json.get("steps", [])
+                    for item in step.get("items", [])
+                )
+
+                if gas_missing:
+                    placeholder_payload = payload.copy()
+                    placeholder_payload["user"] = GAS_ESTIMATE_FALLBACK_ADDRESS
+                    self.logger.info(f"[RELAY PROVIDER] POST {url}")
+                    self.logger.info(
+                        f"[RELAY PROVIDER] BODY {json.dumps(placeholder_payload, indent=2, sort_keys=True)}"
+                    )
+                    placeholder_response = requests.post(
+                        url=url, headers=headers, json=placeholder_payload, timeout=30
+                    )
+                    response_json_placeholder = placeholder_response.json()
+
+                    for i, step in enumerate(response_json.get("steps", [])):
+                        for j, item in enumerate(step.get("items", [])):
+                            if "gas" not in item.get("data", {}):
+                                placeholder_gas = (
+                                    response_json_placeholder.get("steps", {i: {}})[i]
+                                    .get("items", {j: {}})[j]
+                                    .get("data", {})
+                                    .get("gas")
+                                )
+                                item["data"]["gas"] = (
+                                    placeholder_gas
+                                    or RELAY_DEFAULT_GAS[Chain(from_chain)][step["id"]]
+                                )
+
+                quote_data = QuoteData(
+                    eta=math.ceil(response_json["details"]["timeEstimate"]),
+                    elapsed_time=time.time() - start,
+                    message=None,
+                    provider_data={
+                        "attempts": attempt,
+                        "response": response_json,
+                        "response_status": response.status_code,
+                    },
+                    timestamp=int(time.time()),
+                )
+                provider_request.quote_data = quote_data
+                provider_request.status = ProviderRequestStatus.QUOTE_DONE
+                return
+            except requests.Timeout as e:
+                self.logger.warning(
+                    f"[RELAY PROVIDER] Timeout request on attempt {attempt}/{DEFAULT_MAX_QUOTE_RETRIES}: {e}."
+                )
+                quote_data = QuoteData(
+                    eta=None,
+                    elapsed_time=time.time() - start,
+                    message=str(e),
+                    provider_data={
+                        "attempts": attempt,
+                        "response": None,
+                        "response_status": HTTPStatus.GATEWAY_TIMEOUT,
+                    },
+                    timestamp=int(time.time()),
+                )
+            except requests.RequestException as e:
+                self.logger.warning(
+                    f"[RELAY PROVIDER] Request failed on attempt {attempt}/{DEFAULT_MAX_QUOTE_RETRIES}: {e}."
+                )
+                response_json = response.json()
+                quote_data = QuoteData(
+                    eta=None,
+                    elapsed_time=time.time() - start,
+                    message=response_json.get("message") or str(e),
+                    provider_data={
+                        "attempts": attempt,
+                        "response": response_json,
+                        "response_status": getattr(
+                            response, "status_code", HTTPStatus.BAD_GATEWAY
+                        ),
+                    },
+                    timestamp=int(time.time()),
+                )
+            except Exception as e:  # pylint:disable=broad-except
+                self.logger.warning(
+                    f"[RELAY PROVIDER] Request failed on attempt {attempt}/{DEFAULT_MAX_QUOTE_RETRIES}: {e}."
+                )
+                quote_data = QuoteData(
+                    eta=None,
+                    elapsed_time=time.time() - start,
+                    message=str(e),
+                    provider_data={
+                        "attempts": attempt,
+                        "response": None,
+                        "response_status": HTTPStatus.INTERNAL_SERVER_ERROR,
+                    },
+                    timestamp=int(time.time()),
+                )
+            if attempt >= DEFAULT_MAX_QUOTE_RETRIES:
+                self.logger.error(
+                    f"[RELAY PROVIDER] Request failed after {DEFAULT_MAX_QUOTE_RETRIES} attempts."
+                )
+                provider_request.quote_data = quote_data
+                provider_request.status = ProviderRequestStatus.QUOTE_FAILED
+                return
+
+            time.sleep(2)
+
+    def _get_txs(
+        self, provider_request: ProviderRequest, *args: t.Any, **kwargs: t.Any
+    ) -> t.List[t.Tuple[str, t.Dict]]:
+        """Get the sorted list of transactions to execute the quote."""
+
+        if provider_request.params["to"]["amount"] == 0:
+            return []
+
+        quote_data = provider_request.quote_data
+        if not quote_data:
+            raise RuntimeError(
+                f"Cannot get transaction builders {provider_request.id}: quote data not present."
+            )
+
+        provider_data = quote_data.provider_data
+        if not provider_data:
+            raise RuntimeError(
+                f"Cannot get transaction builders {provider_request.id}: provider data not present."
+            )
+
+        txs: t.List[t.Tuple[str, t.Dict]] = []
+
+        response = provider_data.get("response")
+        if not response:
+            return txs
+
+        steps = response.get("steps", [])
+        from_ledger_api = self._from_ledger_api(provider_request)
+
+        for step in steps:
+            for i, item in enumerate(step["items"]):
+                tx = item["data"].copy()
+                tx["to"] = from_ledger_api.api.to_checksum_address(tx["to"])
+                tx["value"] = int(tx.get("value", 0))
+                tx["gas"] = int(tx.get("gas", 1))
+                tx["maxFeePerGas"] = int(tx.get("maxFeePerGas", 0))
+                tx["maxPriorityFeePerGas"] = int(tx.get("maxPriorityFeePerGas", 0))
+                tx["nonce"] = from_ledger_api.api.eth.get_transaction_count(tx["from"])
+                Provider._update_with_gas_pricing(tx, from_ledger_api)
+                Provider._update_with_gas_estimate(tx, from_ledger_api)
+                txs.append((f"{step['id']}-{i}", tx))
+
+        return txs
+
+    def _update_execution_status(self, provider_request: ProviderRequest) -> None:
+        """Update the execution status."""
+
+        if provider_request.status not in (
+            ProviderRequestStatus.EXECUTION_PENDING,
+            ProviderRequestStatus.EXECUTION_UNKNOWN,
+        ):
+            return
+
+        execution_data = provider_request.execution_data
+        if not execution_data:
+            raise RuntimeError(
+                f"Cannot update request {provider_request.id}: execution data not present."
+            )
+
+        from_tx_hash = execution_data.from_tx_hash
+        if not from_tx_hash:
+            execution_data.message = (
+                f"{MESSAGE_EXECUTION_FAILED} missing transaction hash."
+            )
+            provider_request.status = ProviderRequestStatus.EXECUTION_FAILED
+            return
+
+        relay_status = RelayExecutionStatus.WAITING
+        url = "https://api.relay.link/requests/v2"
+        headers = {"accept": "application/json"}
+        params = {
+            "hash": from_tx_hash,
+            "sortBy": "createdAt",
+        }
+
+        try:
+            self.logger.info(f"[RELAY PROVIDER] GET {url}?{urlencode(params)}")
+            response = requests.get(url=url, headers=headers, params=params, timeout=30)
+            response_json = response.json()
+            relay_requests = response_json.get("requests")
+            if relay_requests:
+                relay_status = relay_requests[0].get(
+                    "status", str(RelayExecutionStatus.WAITING)
+                )
+                execution_data.message = str(relay_status)
+            response.raise_for_status()
+        except Exception as e:
+            self.logger.error(
+                f"[RELAY PROVIDER] Failed to update status for request {provider_request.id}: {e}"
+            )
+
+        if relay_status == RelayExecutionStatus.SUCCESS:
+            self.logger.info(
+                f"[RELAY PROVIDER] Execution done for {provider_request.id}."
+            )
+            from_ledger_api = self._from_ledger_api(provider_request)
+            to_ledger_api = self._to_ledger_api(provider_request)
+            to_tx_hash = response_json["requests"][0]["data"]["outTxs"][0]["hash"]
+            execution_data.message = response_json.get("details", None)
+            execution_data.to_tx_hash = to_tx_hash
+            execution_data.elapsed_time = Provider._tx_timestamp(
+                to_tx_hash, to_ledger_api
+            ) - Provider._tx_timestamp(from_tx_hash, from_ledger_api)
+            provider_request.status = ProviderRequestStatus.EXECUTION_DONE
+            execution_data.provider_data = {
+                "response": response_json,
+            }
+        elif relay_status in (
+            RelayExecutionStatus.FAILURE,
+            RelayExecutionStatus.REFUND,
+        ):
+            provider_request.status = ProviderRequestStatus.EXECUTION_FAILED
+        elif relay_status in (
+            RelayExecutionStatus.PENDING,
+            RelayExecutionStatus.DELAYED,
+        ):
+            provider_request.status = ProviderRequestStatus.EXECUTION_PENDING
+        else:
+            provider_request.status = ProviderRequestStatus.EXECUTION_UNKNOWN
+
+    def _get_explorer_link(self, provider_request: ProviderRequest) -> t.Optional[str]:
+        """Get the explorer link for a transaction."""
+        if not provider_request.execution_data:
+            return None
+
+        quote_data = provider_request.quote_data
+        if not quote_data:
+            raise RuntimeError(
+                f"Cannot get explorer link for request {provider_request.id}: quote data not present."
+            )
+
+        provider_data = quote_data.provider_data
+        if not provider_data:
+            return None
+
+        steps = provider_data.get("response", {}).get("steps", [])
+        if not steps:
+            return None
+
+        request_id = steps[-1].get("requestId")
+        return f"https://relay.link/transaction/{request_id}"

operate/cli.py

@@ -45,8 +45,15 @@ from uvicorn.server import Server
 
 from operate import services
 from operate.account.user import UserAccount
-from operate.bridge.bridge import BridgeManager
-from operate.constants import KEY, KEYS, OPERATE_HOME, SERVICES, ZERO_ADDRESS
+from operate.bridge.bridge_manager import BridgeManager
+from operate.constants import (
+    KEY,
+    KEYS,
+    MIN_PASSWORD_LENGTH,
+    OPERATE_HOME,
+    SERVICES,
+    ZERO_ADDRESS,
+)
 from operate.ledger.profiles import (
     DEFAULT_MASTER_EOA_FUNDS,
     DEFAULT_NEW_SAFE_FUNDS,
@@ -56,6 +63,7 @@ from operate.migration import MigrationManager
 from operate.operate_types import Chain, DeploymentStatus, LedgerType
 from operate.quickstart.analyse_logs import analyse_logs
 from operate.quickstart.claim_staking_rewards import claim_staking_rewards
+from operate.quickstart.reset_configs import reset_configs
 from operate.quickstart.reset_password import reset_password
 from operate.quickstart.reset_staking import reset_staking
 from operate.quickstart.run_service import run_service
@@ -406,13 +414,19 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         if operate.user_account is not None:
             return JSONResponse(
                 content={"error": "Account already exists"},
+                status_code=HTTPStatus.CONFLICT,
+            )
+
+        password = (await request.json()).get("password")
+        if not password or len(password) < MIN_PASSWORD_LENGTH:
+            return JSONResponse(
+                content={
+                    "error": f"Password must be at least {MIN_PASSWORD_LENGTH} characters long."
+                },
                 status_code=HTTPStatus.BAD_REQUEST,
             )
 
-        data = await request.json()
-        operate.create_user_account(
-            password=data["password"],
-        )
+        operate.create_user_account(password=password)
         return JSONResponse(content={"error": None})
 
     @app.put("/api/account")
@@ -424,7 +438,7 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         if operate.user_account is None:
             return JSONResponse(
                 content={"error": "Account does not exist."},
-                status_code=HTTPStatus.BAD_REQUEST,
+                status_code=HTTPStatus.CONFLICT,
             )
 
         data = await request.json()
@@ -448,6 +462,14 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
                 status_code=HTTPStatus.BAD_REQUEST,
             )
 
+        if not new_password or len(new_password) < MIN_PASSWORD_LENGTH:
+            return JSONResponse(
+                content={
+                    "error": f"Password must be at least {MIN_PASSWORD_LENGTH} characters long."
+                },
+                status_code=HTTPStatus.BAD_REQUEST,
+            )
+
         try:
             if old_password:
                 operate.update_password(old_password, new_password)
@@ -537,6 +559,35 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         wallet, mnemonic = manager.create(ledger_type=ledger_type)
         return JSONResponse(content={"wallet": wallet.json, "mnemonic": mnemonic})
 
+    @app.post("/api/wallet/private_key")
+    @with_retries
+    async def _get_private_key(request: Request) -> t.List[t.Dict]:
+        """Get Master EOA private key."""
+        if operate.user_account is None:
+            return JSONResponse(
+                content={
+                    "error": "Cannot retrieve private key; User account does not exist!"
+                },
+                status_code=HTTPStatus.BAD_REQUEST,
+            )
+
+        data = await request.json()
+        password = data.get("password")
+        error = None
+        if operate.password is None:
+            error = {"error": "You need to login before retrieving the private key"}
+        if operate.password != password:
+            error = {"error": "Password is not valid"}
+        if error is not None:
+            return JSONResponse(
+                content=error,
+                status_code=HTTPStatus.UNAUTHORIZED,
+            )
+
+        ledger_type = data.get("ledger_type", LedgerType.ETHEREUM.value)
+        wallet = operate.wallet_manager.load(ledger_type=LedgerType(ledger_type))
+        return JSONResponse(content={"private_key": wallet.crypto.private_key})
+
     @app.get("/api/extended/wallet")
     @with_retries
     async def _get_wallet_safe(request: Request) -> t.List[t.Dict]:
@@ -1145,6 +1196,20 @@ def qs_claim(
     claim_staking_rewards(operate=operate, config_path=config)
 
 
+@_operate.command(name="reset-configs")
+def qs_reset_configs(
+    config: Annotated[str, params.String(help="Quickstart config file path")],
+    attended: Annotated[
+        str, params.String(help="Run in attended/unattended mode (default: true")
+    ] = "true",
+) -> None:
+    """Reset configs."""
+    os.environ["ATTENDED"] = attended.lower()
+    operate = OperateApp()
+    operate.setup()
+    reset_configs(operate=operate, config_path=config)
+
+
 @_operate.command(name="reset-staking")
 def qs_reset_staking(
     config: Annotated[str, params.String(help="Quickstart config file path")],

operate/constants.py

@@ -39,6 +39,7 @@ ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 ON_CHAIN_INTERACT_TIMEOUT = 120.0
 ON_CHAIN_INTERACT_RETRIES = 10
 ON_CHAIN_INTERACT_SLEEP = 3.0
+MIN_PASSWORD_LENGTH = 8
 
 HEALTH_CHECK_URL = "http://127.0.0.1:8716/healthcheck"  # possible DNS issues on windows so use IP address
 SAFE_WEBAPP_URL = "https://app.safe.global/home?safe=gno:"

operate/ledger/profiles.py

@@ -19,6 +19,7 @@
 
 """Chain profiles."""
 
+import enum
 import typing as t
 
 from operate.constants import ZERO_ADDRESS
@@ -154,7 +155,28 @@ STAKING: t.Dict[Chain, t.Dict[str, str]] = {
     },
 }
 
-DEFAULT_MECH_MARKETPLACE_PRIORITY_MECH = "0x552cEA7Bc33CbBEb9f1D90c1D11D2C6daefFd053"
+
+class StakingProgramMechType(enum.Enum):
+    """Staking program mech type."""
+
+    LEGACY_MECH = "legacy_mech"
+    LEGACY_MECH_MARKETPLACE = "legacy_mech_marketplace"
+    MECH_MARKETPLACE = "mech_marketplace"
+
+    def __str__(self) -> str:
+        """Get the string representation of the enum."""
+        return self.value
+
+
+DEFAULT_PRIORITY_MECH_ADDRESS = {
+    StakingProgramMechType.LEGACY_MECH: "0x77af31De935740567Cf4fF1986D04B2c964A786a",
+    StakingProgramMechType.LEGACY_MECH_MARKETPLACE: "0x552cEA7Bc33CbBEb9f1D90c1D11D2C6daefFd053",
+    StakingProgramMechType.MECH_MARKETPLACE: "0xC05e7412439bD7e91730a6880E18d5D5873F632C",
+}
+DEFAULT_PRIORITY_MECH_SERVICE_ID = {
+    StakingProgramMechType.LEGACY_MECH_MARKETPLACE: 975,
+    StakingProgramMechType.MECH_MARKETPLACE: 2182,
+}
 
 
 # ERC20 token addresses
@@ -247,3 +269,17 @@ def get_staking_contract(
         staking_program_id,
         staking_program_id,
     )
+
+
+def get_staking_program_mech_type(
+    staking_program_id: t.Optional[str],
+) -> StakingProgramMechType:
+    """Get the staking program mech type based on the staking program ID."""
+    if staking_program_id is None:
+        return StakingProgramMechType.LEGACY_MECH
+
+    if staking_program_id.startswith("quickstart_beta_mech_marketplace_expert"):
+        return StakingProgramMechType.MECH_MARKETPLACE
+    if "mech_marketplace" in staking_program_id:
+        return StakingProgramMechType.LEGACY_MECH_MARKETPLACE
+    return StakingProgramMechType.LEGACY_MECH