olas-operate-middleware 0.8.2__tar.gz → 0.14.7__tar.gz

olas_operate_middleware-0.14.7/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: olas-operate-middleware
+Version: 0.14.7
+Summary: 
+License-File: LICENSE
+Author: David Vilela
+Author-email: dvilelaf@gmail.com
+Requires-Python: >=3.10,<3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: argon2-cffi (==23.1.0)
+Requires-Dist: clea (==0.1.0rc4)
+Requires-Dist: cryptography (>=46.0.3,<47.0.0)
+Requires-Dist: cytoolz (==0.12.3)
+Requires-Dist: deepdiff (>=8.6.1,<9.0.0)
+Requires-Dist: fastapi (==0.110.3)
+Requires-Dist: halo (==0.0.31)
+Requires-Dist: multiaddr (==0.0.9)
+Requires-Dist: open-aea-cli-ipfs (>=2.0.8,<3.0.0)
+Requires-Dist: open-aea-ledger-cosmos (>=2.0.8,<3.0.0)
+Requires-Dist: open-aea-ledger-ethereum (>=2.0.8,<3.0.0)
+Requires-Dist: open-aea-ledger-ethereum-flashbots (>=2.0.8,<3.0.0)
+Requires-Dist: open-autonomy (>=0.21.8,<0.22.0)
+Requires-Dist: psutil (>=5.9.8,<6.0.0)
+Requires-Dist: pyinstaller (>=6.8.0,<7.0.0)
+Requires-Dist: requests-mock (>=1.12.1,<2.0.0)
+Requires-Dist: uvicorn (==0.27.0)
+Description-Content-Type: text/markdown
+
+<h1 align="center">
+<b>Olas Operate Middleware</b>
+</h1>
+
+A cross-platform python package used to run autonomous agents powered by the OLAS Network.
+
+## Getting Started
+
+Install using
+```
+pip install olas-operate-middleware
+```
+
+Start the daemon service using
+```
+python -m operate.cli daemon
+```
+
+## License
+
+- [Apache 2.0](LICENSE)
+
+## Security
+
+- [Security Policy](SECURITY.md)
+

olas_operate_middleware-0.14.7/operate/__init__.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2023 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.
+#
+# ------------------------------------------------------------------------------
+
+"""Operate app."""
+
+import logging
+import os
+import platform
+from importlib.metadata import PackageNotFoundError, version
+
+import certifi
+
+
+try:
+    # Prefer the distribution name if installed; fall back to the module name
+    __version__ = version("olas-operate-middleware")
+except PackageNotFoundError:
+    try:
+        __version__ = version("operate")
+    except PackageNotFoundError:
+        logger = logging.getLogger("operate")
+        logger.warning("Could not determine version, using 0.0.0+local")
+        __version__ = "0.0.0+local"
+
+logging.getLogger("aea").setLevel(logging.ERROR)
+
+
+# Ensure CA bundle is available for requests
+# This prevents errors when PyInstaller temp directory is cleaned during long-running apps
+# Set REQUESTS_CA_BUNDLE, preferring system CA bundle, falling back to bundled.
+logger = logging.getLogger("operate")
+system = platform.system()
+bundle_set = False
+if system == "Darwin":  # macOS
+    system_bundle = "/etc/ssl/cert.pem"
+    if os.path.exists(system_bundle):
+        os.environ.setdefault("REQUESTS_CA_BUNDLE", system_bundle)
+        bundle_set = True
+elif system == "Linux":
+    system_bundle = "/etc/ssl/certs/ca-certificates.crt"
+    if os.path.exists(system_bundle):
+        os.environ.setdefault("REQUESTS_CA_BUNDLE", system_bundle)
+        bundle_set = True
+elif system == "Windows":
+    # Windows uses the system certificate store by default; no file needed
+    logger.info("Using system certificate store on Windows.")
+    bundle_set = True  # Considered set since system handles it
+else:
+    logger.warning(f"Unknown OS {system}; CA bundle handling not configured.")
+
+# Fallback to bundled if system not available
+if not bundle_set and os.path.exists(certifi.where()):
+    os.environ.setdefault("REQUESTS_CA_BUNDLE", certifi.where())
+elif not bundle_set:
+    logger.warning("No CA certificate bundle available.")

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.14.7}/operate/bridge/bridge_manager.py

@@ -29,7 +29,6 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import cast
 
-from aea.helpers.logging import setup_logger
 from deepdiff import DeepDiff
 from web3 import Web3
 
@@ -43,10 +42,9 @@ from operate.bridge.providers.provider import Provider, ProviderRequest
 from operate.bridge.providers.relay_provider import RelayProvider
 from operate.constants import ZERO_ADDRESS
 from operate.ledger.profiles import USDC
-from operate.operate_types import Chain
+from operate.operate_types import Chain, ChainAmounts
 from operate.resource import LocalResource
 from operate.services.manage import get_assets_balances
-from operate.utils import merge_sum_dicts, subtract_dicts
 from operate.wallet.master import MasterWalletManager
 
 
@@ -59,52 +57,60 @@ RELAY_PROVIDER_ID = "relay-provider"
 
 NATIVE_BRIDGE_PROVIDER_CONFIGS: t.Dict[str, t.Any] = {
     "native-ethereum-to-base": {
-        "from_chain": "ethereum",
+        "from_chain": Chain.ETHEREUM.value,
         "from_bridge": "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
-        "to_chain": "base",
+        "to_chain": Chain.BASE.value,
         "to_bridge": "0x4200000000000000000000000000000000000010",
         "bridge_eta": 300,
         "bridge_contract_adaptor_class": OptimismContractAdaptor,
     },
+    "native-ethereum-to-celo": {
+        "from_chain": Chain.ETHEREUM.value,
+        "from_bridge": "0x9C4955b92F34148dbcfDCD82e9c9eCe5CF2badfe",
+        "to_chain": Chain.CELO.value,
+        "to_bridge": "0x4200000000000000000000000000000000000010",
+        "bridge_eta": 300,
+        "bridge_contract_adaptor_class": OptimismContractAdaptor,
+    },
+    "native-ethereum-to-gnosis": {
+        "from_chain": Chain.ETHEREUM.value,
+        "from_bridge": "0x88ad09518695c6c3712AC10a214bE5109a655671",
+        "to_chain": Chain.GNOSIS.value,
+        "to_bridge": "0xf6A78083ca3e2a662D6dd1703c939c8aCE2e268d",
+        "bridge_eta": 1800,
+        "bridge_contract_adaptor_class": OmnibridgeContractAdaptor,
+    },
     "native-ethereum-to-mode": {
-        "from_chain": "ethereum",
+        "from_chain": Chain.ETHEREUM.value,
         "from_bridge": "0x735aDBbE72226BD52e818E7181953f42E3b0FF21",
-        "to_chain": "mode",
+        "to_chain": Chain.MODE.value,
         "to_bridge": "0x4200000000000000000000000000000000000010",
         "bridge_eta": 300,
         "bridge_contract_adaptor_class": OptimismContractAdaptor,
     },
     "native-ethereum-to-optimism": {
-        "from_chain": "ethereum",
+        "from_chain": Chain.ETHEREUM.value,
         "from_bridge": "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1",
-        "to_chain": "optimistic",
+        "to_chain": Chain.OPTIMISM.value,
         "to_bridge": "0x4200000000000000000000000000000000000010",
         "bridge_eta": 300,
         "bridge_contract_adaptor_class": OptimismContractAdaptor,
     },
-    "native-ethereum-to-gnosis": {
-        "from_chain": "ethereum",
-        "from_bridge": "0x88ad09518695c6c3712AC10a214bE5109a655671",
-        "to_chain": "gnosis",
-        "to_bridge": "0xf6A78083ca3e2a662D6dd1703c939c8aCE2e268d",
-        "bridge_eta": 1800,
-        "bridge_contract_adaptor_class": OmnibridgeContractAdaptor,
-    },
 }
 
-
-ROUTES = {
+# Routes are defined as the tuples (from_chain, from_token, to_chain, to_token)
+PREFERRED_ROUTES = {
     (
-        Chain.ETHEREUM,  # from_chain
-        USDC[Chain.ETHEREUM],  # from_token
-        Chain.OPTIMISTIC,  # to_chain
-        USDC[Chain.OPTIMISTIC],  # to_token
+        Chain.ETHEREUM,
+        USDC[Chain.ETHEREUM],
+        Chain.OPTIMISM,
+        USDC[Chain.OPTIMISM],
     ): LIFI_PROVIDER_ID,
     (
-        Chain.ETHEREUM,  # from_chain
-        USDC[Chain.ETHEREUM],  # from_token
-        Chain.BASE,  # to_chain
-        USDC[Chain.BASE],  # to_token
+        Chain.ETHEREUM,
+        USDC[Chain.ETHEREUM],
+        Chain.BASE,
+        USDC[Chain.BASE],
     ): LIFI_PROVIDER_ID,
     (Chain.ETHEREUM, ZERO_ADDRESS, Chain.GNOSIS, ZERO_ADDRESS): RELAY_PROVIDER_ID,
 }
@@ -187,14 +193,14 @@ class BridgeManager:
         self,
         path: Path,
         wallet_manager: MasterWalletManager,
-        logger: t.Optional[logging.Logger] = None,
-        quote_validity_period: int = DEFAULT_BUNDLE_VALIDITY_PERIOD,
+        logger: logging.Logger,
+        bundle_validity_period: int = DEFAULT_BUNDLE_VALIDITY_PERIOD,
     ) -> None:
         """Initialize bridge manager."""
         self.path = path
         self.wallet_manager = wallet_manager
-        self.logger = logger or setup_logger(name="operate.bridge.BridgeManager")
-        self.quote_validity_period = quote_validity_period
+        self.logger = logger
+        self.bundle_validity_period = bundle_validity_period
         self.path.mkdir(exist_ok=True)
         (self.path / EXECUTED_BUNDLES_PATH).mkdir(exist_ok=True)
         self.data: BridgeManagerData = cast(
@@ -252,7 +258,7 @@ class BridgeManager:
             self.logger.info("[BRIDGE MANAGER] Force bundle update.")
             self.quote_bundle(bundle)
             self._store_data()
-        elif now > bundle.timestamp + self.quote_validity_period:
+        elif now > bundle.timestamp + self.bundle_validity_period:
             self.logger.info("[BRIDGE MANAGER] Bundle expired.")
             self.quote_bundle(bundle)
             self._store_data()
@@ -262,24 +268,26 @@ class BridgeManager:
 
             provider_requests = []
             for params in requests_params:
-                for provider in self._native_bridge_providers.values():
-                    if provider.can_handle_request(params):
-                        provider_requests.append(provider.create_request(params=params))
-                        break
-                else:
-                    provider_id = ROUTES.get(
-                        (
-                            Chain(params["from"]["chain"]),
-                            params["from"]["token"],
-                            Chain(params["to"]["chain"]),
-                            params["to"]["token"],
-                        ),
-                        RELAY_PROVIDER_ID,
-                    )
-
-                    provider_requests.append(
-                        self._providers[provider_id].create_request(params=params)
-                    )
+                route = (
+                    Chain(params["from"]["chain"]),
+                    params["from"]["token"],
+                    Chain(params["to"]["chain"]),
+                    params["to"]["token"],
+                )
+                provider_id = PREFERRED_ROUTES.get(route)
+
+                if not provider_id:
+                    for provider in self._native_bridge_providers.values():
+                        if provider.can_handle_request(params):
+                            provider_id = provider.provider_id
+                            break
+
+                if not provider_id:
+                    provider_id = RELAY_PROVIDER_ID
+
+                provider_requests.append(
+                    self._providers[provider_id].create_request(params=params)
+                )
 
             bundle = ProviderRequestBundle(
                 id=f"{BRIDGE_REQUEST_BUNDLE_PREFIX}{uuid.uuid4()}",
@@ -336,7 +344,7 @@ class BridgeManager:
 
         bundle = self._get_updated_bundle(requests_params, force_update)
 
-        balances = {}
+        balances = ChainAmounts()
         for chain in bundle.get_from_chains():
             ledger_api = self.wallet_manager.load(chain.ledger_type).ledger_api(chain)
             balances[chain.value] = get_assets_balances(
@@ -347,9 +355,8 @@ class BridgeManager:
 
         bridge_total_requirements = self.bridge_total_requirements(bundle)
 
-        bridge_refill_requirements = cast(
-            t.Dict[str, t.Dict[str, t.Dict[str, int]]],
-            subtract_dicts(bridge_total_requirements, balances),
+        bridge_refill_requirements = ChainAmounts.shortfalls(
+            bridge_total_requirements, balances
         )
 
         is_refill_required = any(
@@ -362,10 +369,10 @@ class BridgeManager:
         status_json = self.get_status_json(bundle.id)
         status_json.update(
             {
-                "balances": balances,
-                "bridge_refill_requirements": bridge_refill_requirements,
-                "bridge_total_requirements": bridge_total_requirements,
-                "expiration_timestamp": bundle.timestamp + self.quote_validity_period,
+                "balances": balances.json,
+                "bridge_refill_requirements": bridge_refill_requirements.json,
+                "bridge_total_requirements": bridge_total_requirements.json,
+                "expiration_timestamp": bundle.timestamp + self.bundle_validity_period,
                 "is_refill_required": is_refill_required,
             }
         )
@@ -442,14 +449,14 @@ class BridgeManager:
             "bridge_request_status": provider_request_status,
         }
 
-    def bridge_total_requirements(self, bundle: ProviderRequestBundle) -> t.Dict:
+    def bridge_total_requirements(self, bundle: ProviderRequestBundle) -> ChainAmounts:
         """Sum bridge requirements."""
         requirements = []
         for provider_request in bundle.provider_requests:
             provider = self._providers[provider_request.provider_id]
             requirements.append(provider.requirements(provider_request))
 
-        return merge_sum_dicts(*requirements)
+        return ChainAmounts.add(*requirements)
 
     def quote_bundle(self, bundle: ProviderRequestBundle) -> None:
         """Update the bundle with the quotes."""

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.14.7}/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.8.2 → olas_operate_middleware-0.14.7}/operate/bridge/providers/native_bridge_provider.py

@@ -53,6 +53,11 @@ from operate.data.contracts.l2_standard_bridge.contract import L2StandardBridge
 from operate.data.contracts.optimism_mintable_erc20.contract import (
     OptimismMintableERC20,
 )
+from operate.ledger import (
+    get_default_ledger_api,
+    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
@@ -74,13 +79,15 @@ class BridgeContractAdaptor(ABC):
     ) -> None:
         """Initialize the bridge contract adaptor."""
         super().__init__()
+        if from_chain == to_chain:
+            raise ValueError("from_chain and to_chain cannot be the same.")
         self.from_chain = from_chain
         self.from_bridge = from_bridge
         self.to_chain = to_chain
         self.to_bridge = to_bridge
         self.bridge_eta = bridge_eta
 
-    def can_handle_request(self, to_ledger_api: LedgerApi, params: t.Dict) -> bool:
+    def can_handle_request(self, params: t.Dict) -> bool:
         """Returns 'true' if the contract adaptor can handle a request for 'params'."""
         from_chain = params["from"]["chain"]
         from_token = Web3.to_checksum_address(params["from"]["token"])
@@ -96,7 +103,7 @@ class BridgeContractAdaptor(ABC):
         if from_token == ZERO_ADDRESS and to_token == ZERO_ADDRESS:
             return True
 
-        for token_map in ERC20_TOKENS:
+        for token_map in ERC20_TOKENS.values():
             if (
                 Chain(from_chain) in token_map
                 and Chain(to_chain) in token_map
@@ -157,11 +164,24 @@ class OptimismContractAdaptor(BridgeContractAdaptor):
         ),
     )
 
-    def can_handle_request(self, to_ledger_api: LedgerApi, params: t.Dict) -> bool:
+    def can_handle_request(self, params: t.Dict) -> bool:
         """Returns 'true' if the contract adaptor can handle a request for 'params'."""
 
+        if not super().can_handle_request(params):
+            return False
+
+        from_chain = params["from"]["chain"]
         from_token = Web3.to_checksum_address(params["from"]["token"])
+        from_ledger_api = get_default_ledger_api(Chain(from_chain))
+        to_chain = params["to"]["chain"]
         to_token = Web3.to_checksum_address(params["to"]["token"])
+        to_ledger_api = get_default_ledger_api(Chain(to_chain))
+
+        if from_token == ZERO_ADDRESS and to_token == ZERO_ADDRESS:
+            if not self._l1_standard_bridge_contract.supports_bridge_eth_to(
+                ledger_api=from_ledger_api, contract_address=self.from_bridge
+            ):
+                return False
 
         if to_token != ZERO_ADDRESS:
             try:
@@ -175,7 +195,7 @@ class OptimismContractAdaptor(BridgeContractAdaptor):
             except Exception:  # pylint: disable=broad-except
                 return False
 
-        return super().can_handle_request(to_ledger_api, params)
+        return True
 
     def build_bridge_tx(
         self, from_ledger_api: LedgerApi, provider_request: ProviderRequest
@@ -287,13 +307,13 @@ class OmnibridgeContractAdaptor(BridgeContractAdaptor):
         ),
     )
 
-    def can_handle_request(self, to_ledger_api: LedgerApi, params: t.Dict) -> bool:
+    def can_handle_request(self, params: t.Dict) -> bool:
         """Returns 'true' if the contract adaptor can handle a request for 'params'."""
         from_token = Web3.to_checksum_address(params["from"]["token"])
         if from_token == ZERO_ADDRESS:
             return False
 
-        return super().can_handle_request(to_ledger_api, params)
+        return super().can_handle_request(params)
 
     def build_bridge_tx(
         self, from_ledger_api: LedgerApi, provider_request: ProviderRequest
@@ -417,7 +437,7 @@ class NativeBridgeProvider(Provider):
         bridge_contract_adaptor: BridgeContractAdaptor,
         provider_id: str,
         wallet_manager: MasterWalletManager,
-        logger: t.Optional[logging.Logger] = None,
+        logger: logging.Logger,
     ) -> None:
         """Initialize the provider."""
         self.bridge_contract_adaptor = bridge_contract_adaptor
@@ -427,16 +447,10 @@ class NativeBridgeProvider(Provider):
 
     def can_handle_request(self, params: t.Dict) -> bool:
         """Returns 'true' if the provider can handle a request for 'params'."""
-
         if not super().can_handle_request(params):
             return False
 
-        to_chain = params["to"]["chain"]
-        chain = Chain(to_chain)
-        wallet = self.wallet_manager.load(chain.ledger_type)
-        to_ledger_api = wallet.ledger_api(chain)
-
-        if not self.bridge_contract_adaptor.can_handle_request(to_ledger_api, params):
+        if not self.bridge_contract_adaptor.can_handle_request(params):
             return False
 
         return True
@@ -512,8 +526,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 +548,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(