olas-operate-middleware 0.10.18__tar.gz → 0.10.20__tar.gz

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: olas-operate-middleware
-Version: 0.10.18
+Version: 0.10.20
 Summary: 
 License-File: LICENSE
 Author: David Vilela

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/bridge/providers/lifi_provider.py

@@ -38,6 +38,7 @@ from operate.bridge.providers.provider import (
     QuoteData,
 )
 from operate.constants import ZERO_ADDRESS
+from operate.ledger import update_tx_with_gas_estimate, update_tx_with_gas_pricing
 from operate.operate_types import Chain
 
 
@@ -240,8 +241,8 @@ class LiFiProvider(Provider):
             amount=from_amount,
         )
         approve_tx["gas"] = 200_000  # TODO backport to ERC20 contract as default
-        Provider._update_with_gas_pricing(approve_tx, from_ledger_api)
-        Provider._update_with_gas_estimate(approve_tx, from_ledger_api)
+        update_tx_with_gas_pricing(approve_tx, from_ledger_api)
+        update_tx_with_gas_estimate(approve_tx, from_ledger_api)
         return approve_tx
 
     def _get_bridge_tx(self, provider_request: ProviderRequest) -> t.Optional[t.Dict]:
@@ -285,8 +286,8 @@ class LiFiProvider(Provider):
                 transaction_request["from"]
             ),
         }
-        Provider._update_with_gas_pricing(bridge_tx, from_ledger_api)
-        Provider._update_with_gas_estimate(bridge_tx, from_ledger_api)
+        update_tx_with_gas_pricing(bridge_tx, from_ledger_api)
+        update_tx_with_gas_estimate(bridge_tx, from_ledger_api)
         return bridge_tx
 
     def _get_txs(

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/bridge/providers/native_bridge_provider.py

@@ -53,6 +53,7 @@ from operate.data.contracts.l2_standard_bridge.contract import L2StandardBridge
 from operate.data.contracts.optimism_mintable_erc20.contract import (
     OptimismMintableERC20,
 )
+from operate.ledger import update_tx_with_gas_estimate, update_tx_with_gas_pricing
 from operate.ledger.profiles import ERC20_TOKENS, EXPLORER_URL
 from operate.operate_types import Chain
 from operate.wallet.master import MasterWalletManager
@@ -512,8 +513,8 @@ class NativeBridgeProvider(Provider):
             amount=to_amount,
         )
         approve_tx["gas"] = 200_000  # TODO backport to ERC20 contract as default
-        Provider._update_with_gas_pricing(approve_tx, from_ledger_api)
-        Provider._update_with_gas_estimate(approve_tx, from_ledger_api)
+        update_tx_with_gas_pricing(approve_tx, from_ledger_api)
+        update_tx_with_gas_estimate(approve_tx, from_ledger_api)
         return approve_tx
 
     def _get_bridge_tx(self, provider_request: ProviderRequest) -> t.Optional[t.Dict]:
@@ -534,8 +535,8 @@ class NativeBridgeProvider(Provider):
             from_ledger_api=from_ledger_api, provider_request=provider_request
         )
 
-        Provider._update_with_gas_pricing(bridge_tx, from_ledger_api)
-        Provider._update_with_gas_estimate(bridge_tx, from_ledger_api)
+        update_tx_with_gas_pricing(bridge_tx, from_ledger_api)
+        update_tx_with_gas_estimate(bridge_tx, from_ledger_api)
         return bridge_tx
 
     def _get_txs(

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/bridge/providers/provider.py

@@ -28,7 +28,6 @@ import typing as t
 import uuid
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from math import ceil
 
 from aea.crypto.base import LedgerApi
 from autonomy.chain.tx import TxSettler
@@ -41,16 +40,12 @@ from operate.constants import (
     ON_CHAIN_INTERACT_TIMEOUT,
     ZERO_ADDRESS,
 )
+from operate.ledger import update_tx_with_gas_pricing
 from operate.operate_types import Chain
 from operate.resource import LocalResource
 from operate.wallet.master import MasterWalletManager
 
 
-GAS_ESTIMATE_FALLBACK_ADDRESSES = [
-    "0x000000000000000000000000000000000000dEaD",
-    "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",  # nosec
-]
-
 DEFAULT_MAX_QUOTE_RETRIES = 3
 PROVIDER_REQUEST_PREFIX = "r-"
 MESSAGE_QUOTE_ZERO = "Zero-amount quote requested."
@@ -66,8 +61,6 @@ MESSAGE_REQUIREMENTS_QUOTE_FAILED = "Cannot compute requirements for failed quot
 
 ERC20_APPROVE_SELECTOR = "0x095ea7b3"  # First 4 bytes of Web3.keccak(text='approve(address,uint256)').hex()[:10]
 
-GAS_ESTIMATE_BUFFER = 1.10
-
 
 @dataclass
 class QuoteData(LocalResource):
@@ -291,7 +284,7 @@ class Provider(ABC):
             self.logger.debug(
                 f"[PROVIDER] Processing transaction {tx_label} for request {provider_request.id}."
             )
-            self._update_with_gas_pricing(tx, from_ledger_api)
+            update_tx_with_gas_pricing(tx, from_ledger_api)
             gas_key = "gasPrice" if "gasPrice" in tx else "maxFeePerGas"
             gas_fees = tx.get(gas_key, 0) * tx["gas"]
             tx_value = int(tx.get("value", 0))
@@ -487,48 +480,3 @@ class Provider(ABC):
         receipt = ledger_api.api.eth.get_transaction_receipt(tx_hash)
         block = ledger_api.api.eth.get_block(receipt.blockNumber)
         return block.timestamp
-
-    # TODO backport to open aea/autonomy
-    # TODO This gas pricing management should possibly be done at a lower level in the library
-    @staticmethod
-    def _update_with_gas_pricing(tx: t.Dict, ledger_api: LedgerApi) -> None:
-        tx.pop("maxFeePerGas", None)
-        tx.pop("gasPrice", None)
-        tx.pop("maxPriorityFeePerGas", None)
-
-        gas_pricing = ledger_api.try_get_gas_pricing()
-        if gas_pricing is None:
-            raise RuntimeError("Unable to retrieve gas pricing.")
-
-        if "maxFeePerGas" in gas_pricing and "maxPriorityFeePerGas" in gas_pricing:
-            tx["maxFeePerGas"] = gas_pricing["maxFeePerGas"]
-            tx["maxPriorityFeePerGas"] = gas_pricing["maxPriorityFeePerGas"]
-        elif "gasPrice" in gas_pricing:
-            tx["gasPrice"] = gas_pricing["gasPrice"]
-        else:
-            raise RuntimeError("Retrieved invalid gas pricing.")
-
-    # TODO backport to open aea/autonomy
-    @staticmethod
-    def _update_with_gas_estimate(tx: t.Dict, ledger_api: LedgerApi) -> None:
-        print(
-            f"[PROVIDER] Trying to update transaction gas {tx['from']=} {tx['gas']=}."
-        )
-        original_from = tx["from"]
-        original_gas = tx.get("gas", 1)
-
-        for address in [original_from] + GAS_ESTIMATE_FALLBACK_ADDRESSES:
-            tx["from"] = address
-            tx["gas"] = 1
-            ledger_api.update_with_gas_estimate(tx)
-            if tx["gas"] > 1:
-                print(
-                    f"[PROVIDER] Gas estimated successfully {tx['from']=} {tx['gas']=}."
-                )
-                break
-
-        tx["from"] = original_from
-        if tx["gas"] == 1:
-            tx["gas"] = original_gas
-            print(f"[PROVIDER] Unable to estimate gas. Restored {tx['gas']=}.")
-        tx["gas"] = ceil(tx["gas"] * GAS_ESTIMATE_BUFFER)

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/bridge/providers/relay_provider.py

@@ -39,6 +39,7 @@ from operate.bridge.providers.provider import (
     ProviderRequestStatus,
     QuoteData,
 )
+from operate.ledger import update_tx_with_gas_estimate, update_tx_with_gas_pricing
 from operate.operate_types import Chain
 
 
@@ -258,10 +259,10 @@ class RelayProvider(Provider):
                     timestamp=int(time.time()),
                 )
             except requests.RequestException as e:
+                response_json = response.json()
                 self.logger.warning(
-                    f"[RELAY PROVIDER] Request failed on attempt {attempt}/{DEFAULT_MAX_QUOTE_RETRIES}: {e}."
+                    f"[RELAY PROVIDER] Request failed on attempt {attempt}/{DEFAULT_MAX_QUOTE_RETRIES}: {response_json}."
                 )
-                response_json = response.json()
                 quote_data = QuoteData(
                     eta=None,
                     elapsed_time=time.time() - start,
@@ -338,8 +339,8 @@ class RelayProvider(Provider):
                 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)
+                update_tx_with_gas_pricing(tx, from_ledger_api)
+                update_tx_with_gas_estimate(tx, from_ledger_api)
                 txs.append((f"{step['id']}-{i}", tx))
 
         return txs

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/cli.py

@@ -36,8 +36,6 @@ import psutil
 import requests
 from aea.helpers.logging import setup_logger
 from clea import group, params, run
-from compose.project import ProjectError
-from docker.errors import APIError
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
@@ -415,37 +413,17 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         allow_methods=["GET", "POST", "PUT", "PATCH", "DELETE"],
     )
 
-    def with_retries(f: t.Callable) -> t.Callable:
-        """Retries decorator."""
-
-        async def _call(request: Request) -> JSONResponse:
-            """Call the endpoint."""
-            logger.info(f"Calling `{f.__name__}` with retries enabled")
-            retries = 0
-            while retries < DEFAULT_MAX_RETRIES:
-                try:
-                    return await f(request)
-                except (APIError, ProjectError) as e:
-                    logger.error(f"Error {e}\n{traceback.format_exc()}")
-                    if "has active endpoints" in str(e):
-                        error_msg = "Service is already running."
-                    else:
-                        error_msg = "Service deployment failed. Please check the logs."
-                    return JSONResponse(
-                        content={"error": error_msg},
-                        status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                    )
-                except Exception as e:  # pylint: disable=broad-except
-                    logger.error(f"Error {str(e)}\n{traceback.format_exc()}")
-                retries += 1
+    @app.middleware("http")
+    async def handle_internal_server_error(request: Request, call_next):
+        try:
+            response = await call_next(request)
+        except Exception as e:  # pylint: disable=broad-except
+            logger.error(f"Error {str(e)}\n{traceback.format_exc()}")
             return JSONResponse(
-                content={
-                    "error": "Operation failed after multiple attempts. Please try again later."
-                },
+                content={"error": str(e)},
                 status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
             )
-
-        return _call
+        return response
 
     @app.get(f"/{shutdown_endpoint}")
     async def _kill_server(request: Request) -> JSONResponse:
@@ -464,19 +442,16 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         return JSONResponse(content={"stopped": True})
 
     @app.get("/api")
-    @with_retries
     async def _get_api(request: Request) -> JSONResponse:
         """Get API info."""
         return JSONResponse(content=operate.json)
 
     @app.get("/api/account")
-    @with_retries
     async def _get_account(request: Request) -> t.Dict:
         """Get account information."""
         return {"is_setup": operate.user_account is not None}
 
     @app.post("/api/account")
-    @with_retries
     async def _setup_account(request: Request) -> t.Dict:
         """Setup account."""
         if operate.user_account is not None:
@@ -498,7 +473,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         return JSONResponse(content={"error": None})
 
     @app.put("/api/account")
-    @with_retries
     async def _update_password(  # pylint: disable=too-many-return-statements
         request: Request,
     ) -> t.Dict:
@@ -568,7 +542,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
             )
 
     @app.post("/api/account/login")
-    @with_retries
     async def _validate_password(request: Request) -> t.Dict:
         """Validate password."""
         if operate.user_account is None:
@@ -588,7 +561,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         )
 
     @app.get("/api/wallet")
-    @with_retries
     async def _get_wallets(request: Request) -> t.List[t.Dict]:
         """Get wallets."""
         wallets = []
@@ -597,7 +569,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         return JSONResponse(content=wallets)
 
     @app.post("/api/wallet")
-    @with_retries
     async def _create_wallet(request: Request) -> t.List[t.Dict]:
         """Create wallet"""
         if operate.user_account is None:
@@ -620,7 +591,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         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:
@@ -641,7 +611,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         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]:
         """Get wallets."""
         wallets = []
@@ -650,7 +619,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         return JSONResponse(content=wallets)
 
     @app.get("/api/wallet/safe")
-    @with_retries
     async def _get_safes(request: Request) -> t.List[t.Dict]:
         """Create wallet safe"""
         all_safes = []
@@ -662,7 +630,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         return JSONResponse(content=all_safes)
 
     @app.get("/api/wallet/safe/{chain}")
-    @with_retries
     async def _get_safe(request: Request) -> t.List[t.Dict]:
         """Get safe address"""
         chain = Chain.from_string(request.path_params["chain"])
@@ -792,7 +759,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
             )
 
     @app.put("/api/wallet/safe")
-    @with_retries
     async def _update_safe(request: Request) -> t.List[t.Dict]:
         """Update wallet safe"""
         # TODO: Extract login check as decorator
@@ -845,13 +811,11 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         )
 
     @app.get("/api/v2/services")
-    @with_retries
     async def _get_services(request: Request) -> JSONResponse:
         """Get all services."""
         return JSONResponse(content=operate.service_manager().json)
 
     @app.get("/api/v2/services/validate")
-    @with_retries
     async def _validate_services(request: Request) -> JSONResponse:
         """Validate all services."""
         service_manager = operate.service_manager()
@@ -866,7 +830,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         )
 
     @app.get("/api/v2/services/deployment")
-    @with_retries
     async def _get_services_deployment(request: Request) -> JSONResponse:
         """Get a service deployment."""
         service_manager = operate.service_manager()
@@ -879,7 +842,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         return JSONResponse(content=output)
 
     @app.get("/api/v2/service/{service_config_id}")
-    @with_retries
     async def _get_service(request: Request) -> JSONResponse:
         """Get a service."""
         service_config_id = request.path_params["service_config_id"]
@@ -897,7 +859,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         )
 
     @app.get("/api/v2/service/{service_config_id}/deployment")
-    @with_retries
     async def _get_service_deployment(request: Request) -> JSONResponse:
         """Get a service deployment."""
         service_config_id = request.path_params["service_config_id"]
@@ -911,7 +872,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         return JSONResponse(content=deployment_json)
 
     @app.get("/api/v2/service/{service_config_id}/agent_performance")
-    @with_retries
     async def _get_agent_performance(request: Request) -> JSONResponse:
         """Get the service refill requirements."""
         service_config_id = request.path_params["service_config_id"]
@@ -926,7 +886,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         )
 
     @app.get("/api/v2/service/{service_config_id}/refill_requirements")
-    @with_retries
     async def _get_refill_requirements(request: Request) -> JSONResponse:
         """Get the service refill requirements."""
         service_config_id = request.path_params["service_config_id"]
@@ -941,7 +900,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         )
 
     @app.post("/api/v2/service")
-    @with_retries
     async def _create_services_v2(request: Request) -> JSONResponse:
         """Create a service."""
         if operate.password is None:
@@ -953,7 +911,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         return JSONResponse(content=output.json)
 
     @app.post("/api/v2/service/{service_config_id}")
-    @with_retries
     async def _deploy_and_run_service(request: Request) -> JSONResponse:
         """Deploy a service."""
         if operate.password is None:
@@ -986,7 +943,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
 
     @app.put("/api/v2/service/{service_config_id}")
     @app.patch("/api/v2/service/{service_config_id}")
-    @with_retries
     async def _update_service(request: Request) -> JSONResponse:
         """Update a service."""
         if operate.password is None:
@@ -1022,7 +978,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         return JSONResponse(content=output.json)
 
     @app.post("/api/v2/service/{service_config_id}/deployment/stop")
-    @with_retries
     async def _stop_service_locally(request: Request) -> JSONResponse:
         """Stop a service deployment."""
 
@@ -1045,7 +1000,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         return JSONResponse(content=deployment.json)
 
     @app.post("/api/v2/service/{service_config_id}/onchain/withdraw")
-    @with_retries
     async def _withdraw_onchain(request: Request) -> JSONResponse:
         """Withdraw all the funds from a service."""
 
@@ -1114,7 +1068,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         return JSONResponse(content={"error": None, "message": "Withdrawal successful"})
 
     @app.post("/api/bridge/bridge_refill_requirements")
-    @with_retries
     async def _bridge_refill_requirements(request: Request) -> JSONResponse:
         """Get the bridge refill requirements."""
         if operate.password is None:
@@ -1149,7 +1102,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
             )
 
     @app.post("/api/bridge/execute")
-    @with_retries
     async def _bridge_execute(request: Request) -> JSONResponse:
         """Execute bridge transaction."""
         if operate.password is None:
@@ -1179,14 +1131,12 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
             )
 
     @app.get("/api/bridge/last_executed_bundle_id")
-    @with_retries
     async def _bridge_last_executed_bundle_id(request: Request) -> t.List[t.Dict]:
         """Get last executed bundle id."""
         content = {"id": operate.bridge_manager.last_executed_bundle_id()}
         return JSONResponse(content=content, status_code=HTTPStatus.OK)
 
     @app.get("/api/bridge/status/{id}")
-    @with_retries
     async def _bridge_status(request: Request) -> JSONResponse:
         """Get bridge transaction status."""
 
@@ -1215,7 +1165,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
             )
 
     @app.post("/api/wallet/recovery/initiate")
-    @with_retries
     async def _wallet_recovery_initiate(request: Request) -> JSONResponse:
         """Initiate wallet recovery."""
         if operate.user_account is None:
@@ -1259,7 +1208,6 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
             )
 
     @app.post("/api/wallet/recovery/complete")
-    @with_retries
     async def _wallet_recovery_complete(request: Request) -> JSONResponse:
         """Complete wallet recovery."""
         if operate.user_account is None:

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/constants.py

@@ -42,8 +42,8 @@ AGENT_LOG_ENV_VAR = "LOG_DIR"
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 
 ON_CHAIN_INTERACT_TIMEOUT = 120.0
-ON_CHAIN_INTERACT_RETRIES = 10
-ON_CHAIN_INTERACT_SLEEP = 3.0
+ON_CHAIN_INTERACT_RETRIES = 12
+ON_CHAIN_INTERACT_SLEEP = 5.0
 MIN_PASSWORD_LENGTH = 8
 
 HEALTH_CHECK_URL = "http://127.0.0.1:8716/healthcheck"  # possible DNS issues on windows so use IP address

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/keys.py

@@ -76,6 +76,19 @@ class KeysManager(metaclass=SingletonMeta):
             )
         )
 
+    def get_private_key_file(self, address: str) -> Path:
+        """Get the path to the private key file for the given address."""
+        path = self.path / f"{address}_private_key"
+
+        if path.is_file():
+            return path
+
+        key = self.get(address)
+        private_key = key.private_key
+        path.write_text(private_key, encoding="utf-8")
+        os.chmod(path, 0o600)
+        return path
+
     def get_crypto_instance(self, address: str) -> EthereumCrypto:
         """Get EthereumCrypto instance for the given address."""
         key: Key = Key.from_json(  # type: ignore

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/ledger/__init__.py

@@ -20,6 +20,10 @@
 """Ledger helpers."""
 
 import os
+import typing as t
+from math import ceil
+
+from aea.crypto.base import LedgerApi
 
 from operate.operate_types import Chain
 
@@ -99,3 +103,54 @@ def get_currency_denom(chain: Chain) -> str:
 def get_currency_smallest_unit(chain: Chain) -> str:
     """Get currency denom by chain type."""
     return CURRENCY_SMALLEST_UNITS.get(chain, "Wei")
+
+
+GAS_ESTIMATE_FALLBACK_ADDRESSES = [
+    "0x000000000000000000000000000000000000dEaD",
+    "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",  # nosec
+]
+GAS_ESTIMATE_BUFFER = 1.10
+
+
+# TODO backport to open aea/autonomy
+# TODO This gas pricing management should be done at a lower level in the library
+def update_tx_with_gas_pricing(tx: t.Dict, ledger_api: LedgerApi) -> None:
+    """Update transaction with gas pricing."""
+    tx.pop("maxFeePerGas", None)
+    tx.pop("gasPrice", None)
+    tx.pop("maxPriorityFeePerGas", None)
+
+    gas_pricing = ledger_api.try_get_gas_pricing()
+    if gas_pricing is None:
+        raise RuntimeError("Unable to retrieve gas pricing.")
+
+    if "maxFeePerGas" in gas_pricing and "maxPriorityFeePerGas" in gas_pricing:
+        tx["maxFeePerGas"] = gas_pricing["maxFeePerGas"]
+        tx["maxPriorityFeePerGas"] = gas_pricing["maxPriorityFeePerGas"]
+    elif "gasPrice" in gas_pricing:
+        tx["gasPrice"] = gas_pricing["gasPrice"]
+    else:
+        raise RuntimeError("Retrieved invalid gas pricing.")
+
+
+# TODO backport to open aea/autonomy
+# TODO This gas management should be done at a lower level in the library
+def update_tx_with_gas_estimate(tx: t.Dict, ledger_api: LedgerApi) -> None:
+    """Update transaction with gas estimate."""
+    print(f"[PROVIDER] Trying to update transaction gas {tx['from']=} {tx['gas']=}.")
+    original_from = tx["from"]
+    original_gas = tx.get("gas", 1)
+
+    for address in [original_from] + GAS_ESTIMATE_FALLBACK_ADDRESSES:
+        tx["from"] = address
+        tx["gas"] = 1
+        ledger_api.update_with_gas_estimate(tx)
+        if tx["gas"] > 1:
+            print(f"[PROVIDER] Gas estimated successfully {tx['from']=} {tx['gas']=}.")
+            break
+
+    tx["from"] = original_from
+    if tx["gas"] == 1:
+        tx["gas"] = original_gas
+        print(f"[PROVIDER] Unable to estimate gas. Restored {tx['gas']=}.")
+    tx["gas"] = ceil(tx["gas"] * GAS_ESTIMATE_BUFFER)

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/quickstart/run_service.py

@@ -34,12 +34,7 @@ from halo import Halo  # type: ignore[import]
 from web3.exceptions import Web3Exception
 
 from operate.account.user import UserAccount
-from operate.constants import (
-    IPFS_ADDRESS,
-    NO_STAKING_PROGRAM_ID,
-    OPERATE_HOME,
-    USER_JSON,
-)
+from operate.constants import IPFS_ADDRESS, NO_STAKING_PROGRAM_ID, USER_JSON
 from operate.data import DATA_DIR
 from operate.data.contracts.staking_token.contract import StakingTokenContract
 from operate.ledger.profiles import STAKING, get_staking_contract
@@ -145,7 +140,8 @@ def ask_confirm_password() -> str:
 
 def load_local_config(operate: "OperateApp", service_name: str) -> QuickstartConfig:
     """Load the local quickstart configuration."""
-    old_path = OPERATE_HOME / "local_config.json"
+    operate_home = operate._path
+    old_path = operate_home / "local_config.json"
     if old_path.exists():  # Migrate to new naming scheme
         config = t.cast(QuickstartConfig, QuickstartConfig.load(old_path))
         service_manager = operate.service_manager()
@@ -178,13 +174,13 @@ def load_local_config(operate: "OperateApp", service_name: str) -> QuickstartCon
                     shutil.move(old_path, config.path)
                     break
 
-    for qs_config in OPERATE_HOME.glob("*-quickstart-config.json"):
+    for qs_config in operate_home.glob("*-quickstart-config.json"):
         if f"{service_name}-quickstart-config.json" == qs_config.name:
             config = t.cast(QuickstartConfig, QuickstartConfig.load(qs_config))
             break
     else:
         config = QuickstartConfig(
-            OPERATE_HOME / f"{service_name}-quickstart-config.json"
+            operate_home / f"{service_name}-quickstart-config.json"
         )
 
     return config

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/services/agent_runner.py

@@ -65,10 +65,10 @@ class AgentRelease:
 # list of agents releases supported
 AGENTS_SUPPORTED = {
     "valory/trader": AgentRelease(
-        owner="valory-xyz", repo="trader", release="v0.0.101"
+        owner="valory-xyz", repo="trader", release="v0.27.2-rc.1"
     ),
     "valory/optimus": AgentRelease(
-        owner="valory-xyz", repo="optimus", release="v0.0.103"
+        owner="valory-xyz", repo="optimus", release="v0.0.1051"
     ),
     "dvilela/memeooorr": AgentRelease(
         owner="valory-xyz", repo="meme-ooorr", release="v0.0.101"

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/services/health_checker.py

@@ -36,10 +36,10 @@ from operate.services.manage import ServiceManager  # type: ignore
 class HealthChecker:
     """Health checker manager."""
 
-    SLEEP_PERIOD_DEFAULT = 30
+    SLEEP_PERIOD_DEFAULT = 5  # seconds
     PORT_UP_TIMEOUT_DEFAULT = 300  # seconds
-    REQUEST_TIMEOUT_DEFAULT = 90
-    NUMBER_OF_FAILS_DEFAULT = 10
+    REQUEST_TIMEOUT_DEFAULT = 90  # seconds
+    NUMBER_OF_FAILS_DEFAULT = 60
 
     def __init__(
         self,
@@ -180,7 +180,7 @@ class HealthChecker:
                             f"[HEALTH_CHECKER] {service_config_id} not healthy for {fails} time in a row"
                         )
                     else:
-                        self.logger.info(
+                        self.logger.debug(
                             f"[HEALTH_CHECKER] {service_config_id} is HEALTHY"
                         )
                         # reset fails if comes healty

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/services/manage.py

@@ -415,18 +415,26 @@ class ServiceManager:
             and (
                 on_chain_hash != service.hash
                 or current_agent_id != staking_params["agent_ids"][0]
-                or current_agent_bond != staking_params["min_staking_deposit"]
+                or (
+                    user_params.use_staking
+                    and current_agent_bond != staking_params["min_staking_deposit"]
+                )
+                # TODO Missing complete this check for non-staked services it should compare the current_agent_bond from the protocol, now it's only read for the staking contract.
                 or on_chain_description != service.description
             )
         )
         current_staking_program = self._get_current_staking_program(service, chain)
 
+        self.logger.info(f"{chain_data.token=}")
+        self.logger.info(f"{user_params.use_staking=}")
         self.logger.info(f"{current_staking_program=}")
         self.logger.info(f"{user_params.staking_program_id=}")
         self.logger.info(f"{on_chain_hash=}")
         self.logger.info(f"{service.hash=}")
         self.logger.info(f"{current_agent_id=}")
-        self.logger.info(f"{staking_params['agent_ids'][0]=}")
+        self.logger.info(f"{staking_params['agent_ids']=}")
+        self.logger.info(f"{current_agent_bond=}")
+        self.logger.info(f"{staking_params['min_staking_deposit']=}")
         self.logger.info(f"{is_first_mint=}")
         self.logger.info(f"{is_update=}")
 
@@ -815,7 +823,12 @@ class ServiceManager:
                 # on_chain_hash != service.hash or  # noqa
                 current_agent_id != target_staking_params["agent_ids"][0]
                 # TODO This has to be removed for Optimus (needs to be properly implemented). Needs to be put back for Trader!
-                or current_agent_bond != target_staking_params["min_staking_deposit"]
+                or (
+                    user_params.use_staking
+                    and current_agent_bond
+                    != target_staking_params["min_staking_deposit"]
+                )
+                # TODO Missing complete this check for non-staked services it should compare the current_agent_bond from the protocol, now it's only read for the staking contract.
                 or current_staking_params["staking_token"]
                 != target_staking_params["staking_token"]
                 or on_chain_description != service.description
@@ -823,12 +836,13 @@ class ServiceManager:
         )
 
         self.logger.info(f"{chain_data.token=}")
+        self.logger.info(f"{user_params.use_staking=}")
         self.logger.info(f"{current_staking_program=}")
         self.logger.info(f"{user_params.staking_program_id=}")
         self.logger.info(f"{on_chain_hash=}")
         self.logger.info(f"{service.hash=}")
         self.logger.info(f"{current_agent_id=}")
-        self.logger.info(f"{target_staking_params['agent_ids'][0]=}")
+        self.logger.info(f"{target_staking_params['agent_ids']=}")
         self.logger.info(f"{current_agent_bond=}")
         self.logger.info(f"{target_staking_params['min_staking_deposit']=}")
         self.logger.info(f"{is_first_mint=}")

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/utils/__init__.py

@@ -19,7 +19,6 @@
 
 """Helper utilities."""
 
-import functools
 import shutil
 import time
 import typing as t
@@ -32,34 +31,6 @@ class SingletonMeta(type):
 
     _instances: t.Dict[t.Type, t.Any] = {}
     _lock: Lock = Lock()
-    _class_locks: t.Dict[t.Type, Lock] = {}
-
-    def __new__(
-        cls, name: str, bases: t.Tuple[type, ...], dct: t.Dict[str, t.Any]
-    ) -> t.Type:
-        """Create a new class with thread-safe methods."""
-        # Wrap all callable methods (except special methods) with thread safety
-        for key, value in list(dct.items()):
-            if callable(value) and not key.startswith("__"):
-                dct[key] = cls._make_thread_safe(value)
-
-        new_class = super().__new__(cls, name, bases, dct)
-        cls._class_locks[new_class] = Lock()
-        return new_class
-
-    @staticmethod
-    def _make_thread_safe(func: t.Callable) -> t.Callable:
-        """Wrap a function to make it thread-safe."""
-
-        @functools.wraps(func)
-        def wrapper(self: t.Any, *args: t.Any, **kwargs: t.Any) -> t.Any:
-            class_lock = SingletonMeta._class_locks.get(type(self))
-            if class_lock:
-                with class_lock:
-                    return func(self, *args, **kwargs)
-            return func(self, *args, **kwargs)
-
-        return wrapper
 
     def __call__(cls, *args: t.Any, **kwargs: t.Any) -> t.Any:
         """Override the __call__ method to control instance creation."""

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/operate/wallet/master.py

@@ -42,7 +42,11 @@ from operate.constants import (
     ON_CHAIN_INTERACT_TIMEOUT,
     ZERO_ADDRESS,
 )
-from operate.ledger import get_default_rpc
+from operate.ledger import (
+    get_default_rpc,
+    update_tx_with_gas_estimate,
+    update_tx_with_gas_pricing,
+)
 from operate.ledger.profiles import ERC20_TOKENS, OLAS, USDC
 from operate.operate_types import Chain, LedgerType
 from operate.resource import LocalResource
@@ -357,10 +361,9 @@ class EthereumMasterWallet(MasterWallet):
                     "nonce": ledger_api.api.eth.get_transaction_count(wallet_address),
                 }
             )
-            return ledger_api.update_with_gas_estimate(
-                transaction=tx,
-                raise_on_try=False,
-            )
+            update_tx_with_gas_pricing(tx, ledger_api)
+            update_tx_with_gas_estimate(tx, ledger_api)
+            return tx
 
         setattr(tx_settler, "build", _build_transfer_tx)  # noqa: B010
         tx_receipt = tx_settler.transact(

{olas_operate_middleware-0.10.18 → olas_operate_middleware-0.10.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "olas-operate-middleware"
-version = "0.10.18"
+version = "0.10.20"
 description = ""
 authors = ["David Vilela <dvilelaf@gmail.com>", "Viraj Patel <vptl185@gmail.com>"]
 readme = "README.md"