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

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: olas-operate-middleware
-Version: 0.8.2
+Version: 0.10.0
 Summary: 
 Author: David Vilela
 Author-email: dvilelaf@gmail.com
@@ -34,7 +34,7 @@ Requires-Dist: open-aea-cli-ipfs (==1.65.0)
 Requires-Dist: open-aea-ledger-cosmos (==1.65.0)
 Requires-Dist: open-aea-ledger-ethereum (==1.65.0)
 Requires-Dist: open-aea-ledger-ethereum-flashbots (==1.65.0)
-Requires-Dist: open-autonomy (>=0.19.11,<0.20.0)
+Requires-Dist: open-autonomy (>=0.20.0,<0.21.0)
 Requires-Dist: psutil (>=5.9.8,<6.0.0)
 Requires-Dist: pyinstaller (>=6.8.0,<7.0.0)
 Requires-Dist: requests-toolbelt (==1.0.0)

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.10.0}/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
 
@@ -77,7 +76,7 @@ NATIVE_BRIDGE_PROVIDER_CONFIGS: t.Dict[str, t.Any] = {
     "native-ethereum-to-optimism": {
         "from_chain": "ethereum",
         "from_bridge": "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1",
-        "to_chain": "optimistic",
+        "to_chain": "optimism",
         "to_bridge": "0x4200000000000000000000000000000000000010",
         "bridge_eta": 300,
         "bridge_contract_adaptor_class": OptimismContractAdaptor,
@@ -97,8 +96,8 @@ ROUTES = {
     (
         Chain.ETHEREUM,  # from_chain
         USDC[Chain.ETHEREUM],  # from_token
-        Chain.OPTIMISTIC,  # to_chain
-        USDC[Chain.OPTIMISTIC],  # to_token
+        Chain.OPTIMISM,  # to_chain
+        USDC[Chain.OPTIMISM],  # to_token
     ): LIFI_PROVIDER_ID,
     (
         Chain.ETHEREUM,  # from_chain
@@ -187,13 +186,13 @@ class BridgeManager:
         self,
         path: Path,
         wallet_manager: MasterWalletManager,
-        logger: t.Optional[logging.Logger] = None,
+        logger: logging.Logger,
         quote_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.logger = logger
         self.quote_validity_period = quote_validity_period
         self.path.mkdir(exist_ok=True)
         (self.path / EXECUTED_BUNDLES_PATH).mkdir(exist_ok=True)

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.10.0}/operate/bridge/providers/native_bridge_provider.py

@@ -417,7 +417,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

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.10.0}/operate/bridge/providers/provider.py

@@ -31,7 +31,6 @@ from dataclasses import dataclass
 from math import ceil
 
 from aea.crypto.base import LedgerApi
-from aea.helpers.logging import setup_logger
 from autonomy.chain.tx import TxSettler
 from web3 import Web3
 from web3.middleware import geth_poa_middleware
@@ -145,12 +144,12 @@ class Provider(ABC):
         self,
         wallet_manager: MasterWalletManager,
         provider_id: str,
-        logger: t.Optional[logging.Logger] = None,
+        logger: logging.Logger,
     ) -> None:
         """Initialize the provider."""
         self.wallet_manager = wallet_manager
         self.provider_id = provider_id
-        self.logger = logger or setup_logger(name="operate.bridge.providers.Provider")
+        self.logger = logger
 
     def description(self) -> str:
         """Get a human-readable description of the provider."""
@@ -231,7 +230,7 @@ class Provider(ABC):
         ledger_api = wallet.ledger_api(chain)
 
         # TODO: Backport to open aea/autonomy
-        if chain == Chain.OPTIMISTIC:
+        if chain == Chain.OPTIMISM:
             ledger_api.api.middleware_onion.inject(geth_poa_middleware, layer=0)
 
         return ledger_api
@@ -244,7 +243,7 @@ class Provider(ABC):
         ledger_api = wallet.ledger_api(chain)
 
         # TODO: Backport to open aea/autonomy
-        if chain == Chain.OPTIMISTIC:
+        if chain == Chain.OPTIMISM:
             ledger_api.api.middleware_onion.inject(geth_poa_middleware, layer=0)
 
         return ledger_api

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.10.0}/operate/bridge/providers/relay_provider.py

@@ -91,7 +91,7 @@ RELAY_DEFAULT_GAS = {
         "swap": 1_500_000,
         "send": 1,
     },
-    Chain.OPTIMISTIC: {
+    Chain.OPTIMISM: {
         "deposit": 50_000,
         "approve": 200_000,
         "authorize": 1,

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.10.0}/operate/cli.py

@@ -28,10 +28,13 @@ import traceback
 import typing as t
 import uuid
 from concurrent.futures import ThreadPoolExecutor
+from contextlib import asynccontextmanager, suppress
 from http import HTTPStatus
 from pathlib import Path
 from types import FrameType
 
+import psutil
+import requests
 from aea.helpers.logging import setup_logger
 from clea import group, params, run
 from compose.project import ProjectError
@@ -47,11 +50,10 @@ from operate import services
 from operate.account.user import UserAccount
 from operate.bridge.bridge_manager import BridgeManager
 from operate.constants import (
-    KEY,
-    KEYS,
+    KEYS_DIR,
     MIN_PASSWORD_LENGTH,
     OPERATE_HOME,
-    SERVICES,
+    SERVICES_DIR,
     ZERO_ADDRESS,
 )
 from operate.ledger.profiles import (
@@ -69,6 +71,7 @@ from operate.quickstart.reset_staking import reset_staking
 from operate.quickstart.run_service import run_service
 from operate.quickstart.stop_service import stop_service
 from operate.quickstart.terminate_on_chain_service import terminate_service
+from operate.services.deployment_runner import stop_deployment_manager
 from operate.services.health_checker import HealthChecker
 from operate.utils import subtract_dicts
 from operate.utils.gnosis import get_assets_balances
@@ -83,6 +86,7 @@ ACCOUNT_NOT_FOUND_ERROR = JSONResponse(
     content={"error": "User account not found."},
     status_code=HTTPStatus.NOT_FOUND,
 )
+TRY_TO_SHUTDOWN_PREVIOUS_INSTANCE = True
 
 
 def service_not_found_error(service_config_id: str) -> JSONResponse:
@@ -104,13 +108,12 @@ class OperateApp:
         """Initialize object."""
         super().__init__()
         self._path = (home or OPERATE_HOME).resolve()
-        self._services = self._path / SERVICES
-        self._keys = self._path / KEYS
-        self._master_key = self._path / KEY
+        self._services = self._path / SERVICES_DIR
+        self._keys = self._path / KEYS_DIR
         self.setup()
 
         self.logger = logger or setup_logger(name="operate")
-        self.keys_manager = services.manage.KeysManager(
+        services.manage.KeysManager(
             path=self._keys,
             logger=self.logger,
         )
@@ -118,6 +121,9 @@ class OperateApp:
 
         mm = MigrationManager(self._path, self.logger)
         mm.migrate_user_account()
+        mm.migrate_services(self.service_manager())
+        mm.migrate_wallets(self.wallet_manager)
+        mm.migrate_qs_configs()
 
     def create_user_account(self, password: str) -> UserAccount:
         """Create a user account."""
@@ -164,7 +170,6 @@ class OperateApp:
         """Load service manager."""
         return services.manage.ServiceManager(
             path=self._services,
-            keys_manager=self.keys_manager,
             wallet_manager=self.wallet_manager,
             logger=self.logger,
             skip_dependency_check=skip_dependency_check,
@@ -185,6 +190,7 @@ class OperateApp:
         manager = MasterWalletManager(
             path=self._path / "wallets",
             password=self.password,
+            logger=self.logger,
         )
         manager.setup()
         return manager
@@ -195,6 +201,7 @@ class OperateApp:
         manager = BridgeManager(
             path=self._path / "bridge",
             wallet_manager=self.wallet_manager,
+            logger=self.logger,
         )
         return manager
 
@@ -230,26 +237,16 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         logger.warning("Healthchecker is off!!!")
     operate = OperateApp(home=home, logger=logger)
 
-    operate.service_manager().log_directories()
-    logger.info("Migrating service configs...")
-    operate.service_manager().migrate_service_configs()
-    logger.info("Migrating service configs done.")
-    operate.service_manager().log_directories()
-
-    logger.info("Migrating wallet configs...")
-    operate.wallet_manager.migrate_wallet_configs()
-    logger.info("Migrating wallet configs done.")
-
     funding_jobs: t.Dict[str, asyncio.Task] = {}
     health_checker = HealthChecker(
-        operate.service_manager(), number_of_fails=number_of_fails
+        operate.service_manager(), number_of_fails=number_of_fails, logger=logger
     )
     # Create shutdown endpoint
     shutdown_endpoint = uuid.uuid4().hex
     (operate._path / "operate.kill").write_text(  # pylint: disable=protected-access
         shutdown_endpoint
     )
-    thread_pool_executor = ThreadPoolExecutor()
+    thread_pool_executor = ThreadPoolExecutor(max_workers=12)
 
     async def run_in_executor(fn: t.Callable, *args: t.Any) -> t.Any:
         loop = asyncio.get_event_loop()
@@ -301,6 +298,12 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         logger.info("Stopping services on startup done.")
 
     def pause_all_services() -> None:
+        service_manager = operate.service_manager()
+        if not service_manager.validate_services():
+            logger.error(
+                "Some services are not valid. Only pausing the valid services."
+            )
+
         service_config_ids = [
             i["service_config_id"] for i in operate.service_manager().json
         ]
@@ -319,7 +322,12 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
             if deployment.status == DeploymentStatus.DELETED:
                 continue
             logger.info(f"stopping service {service_config_id}")
-            deployment.stop(force=True)
+            try:
+                deployment.stop(force=True)
+            except Exception:  # pylint: disable=broad-except
+                logger.exception(
+                    f"Deployment {service_config_id} stopping failed. but continue"
+                )
             logger.info(f"Cancelling funding job for {service_config_id}")
             cancel_funding_job(service_config_id=service_config_id)
             health_checker.stop_for_service(service_config_id=service_config_id)
@@ -338,7 +346,51 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
     # stop all services at  middleware exit
     atexit.register(pause_all_services)
 
-    app = FastAPI()
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        # Load the ML model
+        watchdog_task = set_parent_watchdog(app)
+        yield
+        # Clean up the ML models and release the resources
+
+        with suppress(Exception):
+            watchdog_task.cancel()
+
+        with suppress(Exception):
+            await watchdog_task
+
+    app = FastAPI(lifespan=lifespan)
+
+    def set_parent_watchdog(app):
+        async def stop_app():
+            logger.info("Stopping services on demand...")
+
+            stop_deployment_manager()  # TODO: make it async?
+            await run_in_executor(pause_all_services)
+
+            logger.info("Stopping services on demand done.")
+            app._server.should_exit = True  # pylint: disable=protected-access
+            logger.info("Stopping app.")
+
+        async def check_parent_alive():
+            try:
+                logger.info(
+                    f"Parent alive check task started: ppid is {os.getppid()} and own pid is {os.getpid()}"
+                )
+                while True:
+                    parent = psutil.Process(os.getpid()).parent()
+                    if not parent:
+                        logger.info("Parent is not alive, going to stop")
+                        await stop_app()
+                        return
+                    await asyncio.sleep(3)
+
+            except Exception:  # pylint: disable=broad-except
+                logger.exception("Parent alive check crashed!")
+
+        loop = asyncio.get_running_loop()
+        task = loop.create_task(check_parent_alive())
+        return task
 
     app.add_middleware(
         CORSMiddleware,
@@ -382,16 +434,17 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
     async def _kill_server(request: Request) -> JSONResponse:
         """Kill backend server from inside."""
         os.kill(os.getpid(), signal.SIGINT)
+        return JSONResponse(content={})
 
     @app.get("/shutdown")
     async def _shutdown(request: Request) -> JSONResponse:
         """Kill backend server from inside."""
         logger.info("Stopping services on demand...")
-        pause_all_services()
+        await run_in_executor(pause_all_services)
         logger.info("Stopping services on demand done.")
         app._server.should_exit = True  # pylint: disable=protected-access
         await asyncio.sleep(0.3)
-        return {"stopped": True}
+        return JSONResponse(content={"stopped": True})
 
     @app.get("/api")
     @with_retries
@@ -777,6 +830,21 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
         """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()
+        service_ids = service_manager.get_all_service_ids()
+        _services = [
+            service.service_config_id
+            for service in service_manager.get_all_services()[0]
+        ]
+
+        return JSONResponse(
+            content={service_id: service_id in _services for service_id in service_ids}
+        )
+
     @app.get("/api/v2/service/{service_config_id}")
     @with_retries
     async def _get_service(request: Request) -> JSONResponse:
@@ -954,38 +1022,40 @@ def create_app(  # pylint: disable=too-many-locals, unused-argument, too-many-st
             service = service_manager.load(service_config_id=service_config_id)
 
             # terminate the service on chain
-            for chain in service.chain_configs:
+            for chain, chain_config in service.chain_configs.items():
                 service_manager.terminate_service_on_chain_from_safe(
                     service_config_id=service_config_id,
                     chain=chain,
                     withdrawal_address=withdrawal_address,
                 )
 
-            # drain the master safe and master signer for the home chain
-            chain = Chain(service.home_chain)
-            master_wallet = service_manager.wallet_manager.load(
-                ledger_type=chain.ledger_type
-            )
+                # drain the master safe and master signer for the home chain
+                chain = Chain(service.home_chain)
+                master_wallet = service_manager.wallet_manager.load(
+                    ledger_type=chain.ledger_type
+                )
 
-            # drain the master safe
-            logger.info(
-                f"Draining the Master Safe {master_wallet.safes[chain]} on chain {chain.value} (withdrawal address {withdrawal_address})."
-            )
-            master_wallet.drain(
-                withdrawal_address=withdrawal_address,
-                chain=chain,
-                from_safe=True,
-            )
+                # drain the master safe
+                logger.info(
+                    f"Draining the Master Safe {master_wallet.safes[chain]} on chain {chain.value} (withdrawal address {withdrawal_address})."
+                )
+                master_wallet.drain(
+                    withdrawal_address=withdrawal_address,
+                    chain=chain,
+                    from_safe=True,
+                    rpc=chain_config.ledger_config.rpc,
+                )
 
-            # drain the master signer
-            logger.info(
-                f"Draining the Master Signer {master_wallet.address} on chain {chain.value} (withdrawal address {withdrawal_address})."
-            )
-            master_wallet.drain(
-                withdrawal_address=withdrawal_address,
-                chain=chain,
-                from_safe=False,
-            )
+                # drain the master signer
+                logger.info(
+                    f"Draining the Master Signer {master_wallet.address} on chain {chain.value} (withdrawal address {withdrawal_address})."
+                )
+                master_wallet.drain(
+                    withdrawal_address=withdrawal_address,
+                    chain=chain,
+                    from_safe=False,
+                    rpc=chain_config.ledger_config.rpc,
+                )
         except Exception as e:  # pylint: disable=broad-except
             logger.error(f"Withdrawal failed: {e}\n{traceback.format_exc()}")
             return JSONResponse(
@@ -1136,6 +1206,16 @@ def _daemon(
             }
         )
 
+    # try automatically shutdown previous instance
+    if TRY_TO_SHUTDOWN_PREVIOUS_INSTANCE:
+        url = f"http{'s' if ssl_keyfile and ssl_certfile else ''}://{host}:{port}/shutdown"
+        logger.info(f"trying to stop  previous instance with {url}")
+        try:
+            requests.get(url, timeout=3, verify=False)  # nosec
+            logger.info("previous instance stopped")
+        except Exception:  # pylint: disable=broad-except
+            logger.exception("failed to stop previous instance. probably not running")
+
     server = Server(Config(**config_kwargs))
     app._server = server  # pylint: disable=protected-access
     server.run()

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.10.0}/operate/constants.py

@@ -24,16 +24,11 @@ from pathlib import Path
 
 OPERATE = ".operate"
 OPERATE_HOME = Path.cwd() / OPERATE
-CONFIG = "config.json"
-SERVICES = "services"
-KEYS = "keys"
-DEPLOYMENT = "deployment"
+SERVICES_DIR = "services"
+KEYS_DIR = "keys"
+DEPLOYMENT_DIR = "deployment"
 DEPLOYMENT_JSON = "deployment.json"
-CONFIG = "config.json"
-KEY = "key"
-KEYS_JSON = "keys.json"
-DOCKER_COMPOSE_YAML = "docker-compose.yaml"
-SERVICE_YAML = "service.yaml"
+CONFIG_JSON = "config.json"
 ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 
 ON_CHAIN_INTERACT_TIMEOUT = 120.0
@@ -53,3 +48,8 @@ MECH_ACTIVITY_CHECKER_JSON_URL = "https://raw.githubusercontent.com/valory-xyz/a
 SERVICE_REGISTRY_TOKEN_UTILITY_JSON_URL = "https://raw.githubusercontent.com/valory-xyz/open-autonomy/refs/tags/v0.18.4/packages/valory/contracts/service_registry_token_utility/build/ServiceRegistryTokenUtility.json"  # nosec
 MECH_AGENT_FACTORY_JSON_URL = "https://raw.githubusercontent.com/valory-xyz/ai-registry-mech/main/abis/0.8.25/AgentFactory.json"
 MECH_MARKETPLACE_JSON_URL = "https://raw.githubusercontent.com/valory-xyz/mech-quickstart/refs/heads/main/contracts/MechMarketplace.json"
+NO_STAKING_PROGRAM_ID = "no_staking"
+
+
+DEPLOYMENT_START_TRIES_NUM = 3
+IPFS_CHECK_URL = "https://gateway.autonolas.tech/ipfs/bafybeigcllaxn4ycjjvika3zd6eicksuriez2wtg67gx7pamhcazl3tv54/echo/README.md"

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.10.0}/operate/keys.py

@@ -20,18 +20,18 @@
 """Keys manager."""
 
 import json
-import logging
 import os
 import shutil
-import typing as t
+import tempfile
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Any
 
-from aea.helpers.logging import setup_logger
 from aea_ledger_ethereum.ethereum import EthereumCrypto
 
 from operate.operate_types import LedgerType
 from operate.resource import LocalResource
+from operate.utils import SingletonMeta
 
 
 @dataclass
@@ -48,25 +48,21 @@ class Key(LocalResource):
         return super().load(path)  # type: ignore
 
 
-Keys = t.List[Key]
-
-
-class KeysManager:
+class KeysManager(metaclass=SingletonMeta):
     """Keys manager."""
 
-    def __init__(
-        self,
-        path: Path,
-        logger: t.Optional[logging.Logger] = None,
-    ) -> None:
+    def __init__(self, **kwargs: Any) -> None:
         """
         Initialize keys manager
 
         :param path: Path to keys storage.
         :param logger: logging.Logger object.
         """
-        self.path = path
-        self.logger = logger or setup_logger(name="operate.keys")
+        if "path" not in kwargs:
+            raise ValueError("Path must be provided for KeysManager")
+
+        self.path = kwargs["path"]
+        self.logger = kwargs["logger"]
 
     def setup(self) -> None:
         """Setup service manager."""
@@ -83,6 +79,22 @@ class KeysManager:
             )
         )
 
+    def get_crypto_instance(self, address: str) -> EthereumCrypto:
+        """Get EthereumCrypto instance for the given address."""
+        key: Key = Key.from_json(  # type: ignore
+            obj=json.loads(
+                (self.path / address).read_text(
+                    encoding="utf-8",
+                )
+            )
+        )
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".txt") as temp_file:
+            temp_file.write(key.private_key)
+            temp_file.flush()
+            crypto = EthereumCrypto(private_key_path=temp_file.name)
+
+        return crypto
+
     def create(self) -> str:
         """Creates new key."""
         crypto = EthereumCrypto()

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.10.0}/operate/ledger/__init__.py

@@ -46,7 +46,7 @@ PUBLIC_RPCS = {
     Chain.SOLANA: SOLANA_PUBLIC_RPC,
     Chain.BASE: BASE_PUBLIC_RPC,
     Chain.CELO: CELO_PUBLIC_RPC,
-    Chain.OPTIMISTIC: OPTIMISM_PUBLIC_RPC,
+    Chain.OPTIMISM: OPTIMISM_PUBLIC_RPC,
     Chain.MODE: MODE_PUBLIC_RPC,
 }
 
@@ -56,7 +56,7 @@ DEFAULT_RPCS = {
     Chain.SOLANA: SOLANA_RPC,
     Chain.BASE: BASE_RPC,
     Chain.CELO: CELO_RPC,
-    Chain.OPTIMISTIC: OPTIMISM_RPC,
+    Chain.OPTIMISM: OPTIMISM_RPC,
     Chain.MODE: MODE_RPC,
 }
 
@@ -67,7 +67,7 @@ CURRENCY_DENOMS = {
     Chain.SOLANA: "SOL",
     Chain.BASE: "ETH",
     Chain.CELO: "CELO",
-    Chain.OPTIMISTIC: "ETH",
+    Chain.OPTIMISM: "ETH",
     Chain.MODE: "ETH",
 }
 
@@ -78,7 +78,7 @@ CURRENCY_SMALLEST_UNITS = {
     Chain.SOLANA: "Lamport",
     Chain.BASE: "Wei",
     Chain.CELO: "Wei",
-    Chain.OPTIMISTIC: "Wei",
+    Chain.OPTIMISM: "Wei",
     Chain.MODE: "Wei",
 }
 

{olas_operate_middleware-0.8.2 → olas_operate_middleware-0.10.0}/operate/ledger/profiles.py

@@ -21,12 +21,10 @@
 
 import typing as t
 
-from operate.constants import ZERO_ADDRESS
+from operate.constants import NO_STAKING_PROGRAM_ID, ZERO_ADDRESS
 from operate.operate_types import Chain, ContractAddresses
 
 
-NO_STAKING_PROGRAM_ID = "no_staking"
-
 CONTRACTS: t.Dict[Chain, ContractAddresses] = {
     Chain.GNOSIS: ContractAddresses(
         {
@@ -38,7 +36,7 @@ CONTRACTS: t.Dict[Chain, ContractAddresses] = {
             "multisend": "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",
         }
     ),
-    Chain.OPTIMISTIC: ContractAddresses(
+    Chain.OPTIMISM: ContractAddresses(
         {
             "service_manager": "0xFbBEc0C8b13B38a9aC0499694A69a10204c5E2aB",
             "service_registry": "0x3d77596beb0f130a4415df3D2D8232B3d3D31e44",
@@ -123,7 +121,7 @@ STAKING: t.Dict[Chain, t.Dict[str, str]] = {
         "marketplace_demand_alpha_1": "0x9d6e7aB0B5B48aE5c146936147C639fEf4575231",
         "marketplace_demand_alpha_2": "0x9fb17E549FefcCA630dd92Ea143703CeE4Ea4340",
     },
-    Chain.OPTIMISTIC: {
+    Chain.OPTIMISM: {
         "optimus_alpha_1": "0x88996bbdE7f982D93214881756840cE2c77C4992",
         "optimus_alpha_2": "0xBCA056952D2A7a8dD4A002079219807CFDF9fd29",
         "optimus_alpha_3": "0x0f69f35652B1acdbD769049334f1AC580927E139",
@@ -170,7 +168,7 @@ DEFAULT_PRIORITY_MECH = {  # maps mech marketplace address to its default priori
 # ERC20 token addresses
 OLAS: t.Dict[Chain, str] = {
     Chain.GNOSIS: "0xcE11e14225575945b8E6Dc0D4F2dD4C570f79d9f",
-    Chain.OPTIMISTIC: "0xFC2E6e6BCbd49ccf3A5f029c79984372DcBFE527",
+    Chain.OPTIMISM: "0xFC2E6e6BCbd49ccf3A5f029c79984372DcBFE527",
     Chain.BASE: "0x54330d28ca3357F294334BDC454a032e7f353416",
     Chain.ETHEREUM: "0x0001A500A6B18995B03f44bb040A5fFc28E45CB0",
     Chain.MODE: "0xcfD1D50ce23C46D3Cf6407487B2F8934e96DC8f9",
@@ -178,7 +176,7 @@ OLAS: t.Dict[Chain, str] = {
 
 USDC: t.Dict[Chain, str] = {
     Chain.GNOSIS: "0xDDAfbb505ad214D7b80b1f830fcCc89B60fb7A83",
-    Chain.OPTIMISTIC: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    Chain.OPTIMISM: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
     Chain.BASE: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
     Chain.ETHEREUM: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
     Chain.MODE: "0xd988097fb8612cc24eeC14542bC03424c656005f",
@@ -186,7 +184,7 @@ USDC: t.Dict[Chain, str] = {
 
 WRAPPED_NATIVE_ASSET = {
     Chain.GNOSIS: "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d",
-    Chain.OPTIMISTIC: "0x4200000000000000000000000000000000000006",
+    Chain.OPTIMISM: "0x4200000000000000000000000000000000000006",
     Chain.BASE: "0x4200000000000000000000000000000000000006",
     Chain.ETHEREUM: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
     Chain.MODE: "0x4200000000000000000000000000000000000006",
@@ -209,7 +207,7 @@ DEFAULT_NEW_SAFE_FUNDS: t.Dict[Chain, t.Dict[str, int]] = {
     Chain.MODE: {
         ZERO_ADDRESS: int(1e15 / 4),
     },
-    Chain.OPTIMISTIC: {
+    Chain.OPTIMISM: {
         ZERO_ADDRESS: int(1e15 / 4),
     },
 }
@@ -219,7 +217,7 @@ DEFAULT_MASTER_EOA_FUNDS = {
     Chain.ETHEREUM: {ZERO_ADDRESS: 20_000_000_000_000_000},
     Chain.GNOSIS: {ZERO_ADDRESS: 1_500_000_000_000_000_000},
     Chain.MODE: {ZERO_ADDRESS: 500_000_000_000_000},
-    Chain.OPTIMISTIC: {ZERO_ADDRESS: 5_000_000_000_000_000},
+    Chain.OPTIMISM: {ZERO_ADDRESS: 5_000_000_000_000_000},
 }
 
 EXPLORER_URL = {
@@ -239,7 +237,7 @@ EXPLORER_URL = {
         "tx": "https://modescan.io/tx/{tx_hash}",
         "address": "https://modescan.io/address/{address}",
     },
-    Chain.OPTIMISTIC: {
+    Chain.OPTIMISM: {
         "tx": "https://optimistic.etherscan.io/tx/{tx_hash}",
         "address": "https://optimistic.etherscan.io/address/{address}",
     },