olas-operate-middleware 0.10.6__py3-none-any.whl → 0.10.8__py3-none-any.whl

operate/data/contracts/recovery_module/contract.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------
+#
+#   Copyright 2025 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.
+#
+# ------------------------------------------------------------------------------
+
+"""This module contains the class to connect to the `RecoveryModule` contract."""
+
+
+from typing import Any, Dict
+
+from aea.configurations.base import PublicId
+from aea.contracts.base import Contract
+from aea.crypto.base import LedgerApi
+
+
+PUBLIC_ID = PublicId.from_str("valory/recovery_module:0.1.0")
+
+
+class RecoveryModule(Contract):
+    """The RecoveryModule contract"""
+
+    contract_id = PUBLIC_ID
+
+    @classmethod
+    def get_recover_access_transaction(
+        cls,
+        ledger_api: LedgerApi,
+        contract_address: str,
+        owner: str,
+        service_id: int,
+        raise_on_try: bool = False,
+    ) -> Dict[str, Any]:
+        """Get the recover access transaction."""
+
+        tx_params = ledger_api.build_transaction(
+            contract_instance=cls.get_instance(
+                ledger_api=ledger_api, contract_address=contract_address
+            ),
+            method_name="recoverAccess",
+            method_args={
+                "serviceId": service_id,
+            },
+            tx_args={"sender_address": owner},
+            raise_on_try=raise_on_try,
+        )
+
+        return tx_params

operate/data/contracts/recovery_module/contract.yaml

@@ -0,0 +1,23 @@
+name: recovery_module
+author: valory
+version: 0.1.0
+type: contract
+description: Recovery module
+license: Apache-2.0
+aea_version: '>=1.0.0, <2.0.0'
+fingerprint:
+  __init__.py: bafybeicjlkmxs5ikpgdtgndifstpmmpaixwcbgouvmt6gowuhf5dy3dpgu
+  build/RecoveryModule.json: bafybeifsyjdbprcp4kxpijlpqfovxcf7cv2ujapt3d5zn34wby26ldv4ky
+  contract.py: bafybeifihpwb3etbrnn2hqdizsp5zolis3ur23slt3q5zctcykm5nlvv7q
+fingerprint_ignore_patterns: []
+contracts: []
+class_name: RecoveryModule
+contract_interface_paths:
+  ethereum: build/RecoveryModule.json
+dependencies:
+  open-aea-ledger-ethereum:
+    version: ==1.60.0
+  open-aea-test-autonomy:
+    version: ==0.18.3
+  web3:
+    version: <7,>=6.0.0

operate/keys.py

@@ -92,16 +92,22 @@ class KeysManager(metaclass=SingletonMeta):
             suffix=".txt",
             delete=False,  # Handle cleanup manually
         ) as temp_file:
+            temp_file_name = temp_file.name
             temp_file.write(key.private_key)
             temp_file.flush()
             temp_file.close()  # Close the file before reading
 
             # Set proper file permissions (readable by owner only)
-            os.chmod(temp_file.name, 0o600)
-            crypto = EthereumCrypto(private_key_path=temp_file.name)
+            os.chmod(temp_file_name, 0o600)
+            crypto = EthereumCrypto(private_key_path=temp_file_name)
 
             try:
-                os.unlink(temp_file.name)  # Clean up the temporary file
+                with open(temp_file_name, "r+", encoding="utf-8") as f:
+                    f.seek(0)
+                    f.write("\0" * len(key.private_key))
+                    f.flush()
+                    f.close()
+                os.unlink(temp_file_name)  # Clean up the temporary file
             except OSError as e:
                 self.logger.error(f"Failed to delete temp file {temp_file.name}: {e}")
 

operate/ledger/__init__.py

@@ -24,62 +24,76 @@ import os
 from operate.operate_types import Chain
 
 
-ETHEREUM_PUBLIC_RPC = os.environ.get("ETHEREUM_RPC", "https://ethereum.publicnode.com")
-GNOSIS_PUBLIC_RPC = os.environ.get("GNOSIS_RPC", "https://gnosis-rpc.publicnode.com")
-SOLANA_PUBLIC_RPC = os.environ.get("SOLANA_RPC", "https://api.mainnet-beta.solana.com")
+ARBITRUM_ONE_PUBLIC_RPC = os.environ.get(
+    "ARBITRUM_ONE_RPC", "https://arb1.arbitrum.io/rpc"
+)
 BASE_PUBLIC_RPC = os.environ.get("BASE_RPC", "https://mainnet.base.org")
 CELO_PUBLIC_RPC = os.environ.get("CELO_RPC", "https://forno.celo.org")
-OPTIMISM_PUBLIC_RPC = os.environ.get("OPTIMISM_RPC", "https://mainnet.optimism.io")
+ETHEREUM_PUBLIC_RPC = os.environ.get("ETHEREUM_RPC", "https://ethereum.publicnode.com")
+GNOSIS_PUBLIC_RPC = os.environ.get("GNOSIS_RPC", "https://gnosis-rpc.publicnode.com")
 MODE_PUBLIC_RPC = os.environ.get("MODE_RPC", "https://mainnet.mode.network/")
+OPTIMISM_PUBLIC_RPC = os.environ.get("OPTIMISM_RPC", "https://mainnet.optimism.io")
+POLYGON_PUBLIC_RPC = os.environ.get("POLYGON_RPC", "https://polygon-rpc.com")
+SOLANA_PUBLIC_RPC = os.environ.get("SOLANA_RPC", "https://api.mainnet-beta.solana.com")
 
-ETHEREUM_RPC = os.environ.get("ETHEREUM_RPC", "https://ethereum.publicnode.com")
-GNOSIS_RPC = os.environ.get("GNOSIS_RPC", "https://rpc-gate.autonolas.tech/gnosis-rpc/")
-SOLANA_RPC = os.environ.get("SOLANA_RPC", "https://api.mainnet-beta.solana.com")
+ARBITRUM_ONE_RPC = os.environ.get("ARBITRUM_ONE_RPC", "https://arb1.arbitrum.io/rpc")
 BASE_RPC = os.environ.get("BASE_RPC", "https://mainnet.base.org")
 CELO_RPC = os.environ.get("CELO_RPC", "https://forno.celo.org")
-OPTIMISM_RPC = os.environ.get("OPTIMISM_RPC", "https://mainnet.optimism.io")
+ETHEREUM_RPC = os.environ.get("ETHEREUM_RPC", "https://ethereum.publicnode.com")
+GNOSIS_RPC = os.environ.get("GNOSIS_RPC", "https://rpc-gate.autonolas.tech/gnosis-rpc/")
 MODE_RPC = os.environ.get("MODE_RPC", "https://mainnet.mode.network/")
+OPTIMISM_RPC = os.environ.get("OPTIMISM_RPC", "https://mainnet.optimism.io")
+POLYGON_RPC = os.environ.get("POLYGON_RPC", "https://polygon-rpc.com")
+SOLANA_RPC = os.environ.get("SOLANA_RPC", "https://api.mainnet-beta.solana.com")
 
 PUBLIC_RPCS = {
-    Chain.ETHEREUM: ETHEREUM_PUBLIC_RPC,
-    Chain.GNOSIS: GNOSIS_PUBLIC_RPC,
-    Chain.SOLANA: SOLANA_PUBLIC_RPC,
+    Chain.ARBITRUM_ONE: ARBITRUM_ONE_PUBLIC_RPC,
     Chain.BASE: BASE_PUBLIC_RPC,
     Chain.CELO: CELO_PUBLIC_RPC,
-    Chain.OPTIMISM: OPTIMISM_PUBLIC_RPC,
+    Chain.ETHEREUM: ETHEREUM_PUBLIC_RPC,
+    Chain.GNOSIS: GNOSIS_PUBLIC_RPC,
     Chain.MODE: MODE_PUBLIC_RPC,
+    Chain.OPTIMISM: OPTIMISM_PUBLIC_RPC,
+    Chain.POLYGON: POLYGON_PUBLIC_RPC,
+    Chain.SOLANA: SOLANA_PUBLIC_RPC,
 }
 
 DEFAULT_RPCS = {
-    Chain.ETHEREUM: ETHEREUM_RPC,
-    Chain.GNOSIS: GNOSIS_RPC,
-    Chain.SOLANA: SOLANA_RPC,
+    Chain.ARBITRUM_ONE: ARBITRUM_ONE_RPC,
     Chain.BASE: BASE_RPC,
     Chain.CELO: CELO_RPC,
-    Chain.OPTIMISM: OPTIMISM_RPC,
+    Chain.ETHEREUM: ETHEREUM_RPC,
+    Chain.GNOSIS: GNOSIS_RPC,
     Chain.MODE: MODE_RPC,
+    Chain.OPTIMISM: OPTIMISM_RPC,
+    Chain.POLYGON: POLYGON_RPC,
+    Chain.SOLANA: SOLANA_RPC,
 }
 
 # Base currency for each chain
 CURRENCY_DENOMS = {
-    Chain.ETHEREUM: "ETH",
-    Chain.GNOSIS: "xDAI",
-    Chain.SOLANA: "SOL",
+    Chain.ARBITRUM_ONE: "ETH",
     Chain.BASE: "ETH",
     Chain.CELO: "CELO",
-    Chain.OPTIMISM: "ETH",
+    Chain.ETHEREUM: "ETH",
+    Chain.GNOSIS: "xDAI",
     Chain.MODE: "ETH",
+    Chain.OPTIMISM: "ETH",
+    Chain.POLYGON: "POL",
+    Chain.SOLANA: "SOL",
 }
 
 # Smallest denomination for each chain
 CURRENCY_SMALLEST_UNITS = {
-    Chain.ETHEREUM: "Wei",
-    Chain.GNOSIS: "Wei",
-    Chain.SOLANA: "Lamport",
+    Chain.ARBITRUM_ONE: "Wei",
     Chain.BASE: "Wei",
     Chain.CELO: "Wei",
-    Chain.OPTIMISM: "Wei",
+    Chain.ETHEREUM: "Wei",
+    Chain.GNOSIS: "Wei",
     Chain.MODE: "Wei",
+    Chain.OPTIMISM: "Wei",
+    Chain.POLYGON: "Wei",
+    Chain.SOLANA: "Lamport",
 }
 
 

operate/ledger/profiles.py

@@ -21,64 +21,46 @@
 
 import typing as t
 
+from autonomy.chain.constants import CHAIN_PROFILES, DEFAULT_MULTISEND
+
 from operate.constants import NO_STAKING_PROGRAM_ID, ZERO_ADDRESS
 from operate.operate_types import Chain, ContractAddresses
 
 
-CONTRACTS: t.Dict[Chain, ContractAddresses] = {
-    Chain.GNOSIS: ContractAddresses(
-        {
-            "service_manager": "0x04b0007b2aFb398015B76e5f22993a1fddF83644",
-            "service_registry": "0x9338b5153AE39BB89f50468E608eD9d764B755fD",
-            "service_registry_token_utility": "0xa45E64d13A30a51b91ae0eb182e88a40e9b18eD8",
-            "gnosis_safe_proxy_factory": "0x3C1fF68f5aa342D296d4DEe4Bb1cACCA912D95fE",
-            "gnosis_safe_same_address_multisig": "0x6e7f594f680f7aBad18b7a63de50F0FeE47dfD06",
-            "multisend": "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",
-        }
-    ),
-    Chain.OPTIMISM: ContractAddresses(
-        {
-            "service_manager": "0xFbBEc0C8b13B38a9aC0499694A69a10204c5E2aB",
-            "service_registry": "0x3d77596beb0f130a4415df3D2D8232B3d3D31e44",
-            "service_registry_token_utility": "0xBb7e1D6Cb6F243D6bdE81CE92a9f2aFF7Fbe7eac",
-            "gnosis_safe_proxy_factory": "0x5953f21495BD9aF1D78e87bb42AcCAA55C1e896C",
-            "gnosis_safe_same_address_multisig": "0xb09CcF0Dbf0C178806Aaee28956c74bd66d21f73",
-            "multisend": "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",
-        }
-    ),
-    Chain.ETHEREUM: ContractAddresses(
-        {
-            "service_manager": "0x2EA682121f815FBcF86EA3F3CaFdd5d67F2dB143",
-            "service_registry": "0x48b6af7B12C71f09e2fC8aF4855De4Ff54e775cA",
-            "service_registry_token_utility": "0x3Fb926116D454b95c669B6Bf2E7c3bad8d19affA",
-            "gnosis_safe_proxy_factory": "0x46C0D07F55d4F9B5Eed2Fc9680B5953e5fd7b461",
-            "gnosis_safe_same_address_multisig": "0xfa517d01DaA100cB1932FA4345F68874f7E7eF46",
-            "multisend": "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",
-        }
-    ),
-    Chain.BASE: ContractAddresses(
-        {
-            "service_manager": "0x63e66d7ad413C01A7b49C7FF4e3Bb765C4E4bd1b",
-            "service_registry": "0x3C1fF68f5aa342D296d4DEe4Bb1cACCA912D95fE",
-            "service_registry_token_utility": "0x34C895f302D0b5cf52ec0Edd3945321EB0f83dd5",
-            "gnosis_safe_proxy_factory": "0x22bE6fDcd3e29851B29b512F714C328A00A96B83",
-            "gnosis_safe_same_address_multisig": "0xFbBEc0C8b13B38a9aC0499694A69a10204c5E2aB",
-            "multisend": "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",
-        }
-    ),
-    Chain.MODE: ContractAddresses(
+# TODO: Refactor, remove the usage of CONTRACTS and use CHAIN_PROFILES from Open Autonomy instead.
+CHAINS = [
+    Chain.ARBITRUM_ONE,
+    Chain.BASE,
+    Chain.CELO,
+    Chain.ETHEREUM,
+    Chain.GNOSIS,
+    Chain.MODE,
+    Chain.OPTIMISM,
+    Chain.POLYGON,
+]
+
+CONTRACTS: t.Dict[Chain, ContractAddresses] = {}
+for _chain in CHAINS:
+    profile = CHAIN_PROFILES[_chain.value]
+    CONTRACTS[_chain] = ContractAddresses(
         {
-            "service_manager": "0x63e66d7ad413C01A7b49C7FF4e3Bb765C4E4bd1b",
-            "service_registry": "0x3C1fF68f5aa342D296d4DEe4Bb1cACCA912D95fE",
-            "service_registry_token_utility": "0x34C895f302D0b5cf52ec0Edd3945321EB0f83dd5",
-            "gnosis_safe_proxy_factory": "0xBb7e1D6Cb6F243D6bdE81CE92a9f2aFF7Fbe7eac",
-            "gnosis_safe_same_address_multisig": "0xFbBEc0C8b13B38a9aC0499694A69a10204c5E2aB",
-            "multisend": "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",
+            "service_registry": profile["service_registry"],
+            "service_registry_token_utility": profile["service_registry_token_utility"],
+            "service_manager": profile["service_manager_token"],
+            "gnosis_safe_proxy_factory": profile["gnosis_safe_proxy_factory"],
+            "gnosis_safe_same_address_multisig": profile[
+                "gnosis_safe_same_address_multisig"
+            ],
+            "safe_multisig_with_recovery_module": profile[
+                "safe_multisig_with_recovery_module"
+            ],
+            "recovery_module": profile["recovery_module"],
+            "multisend": DEFAULT_MULTISEND,
         }
-    ),
-}
+    )
 
 STAKING: t.Dict[Chain, t.Dict[str, str]] = {
+    Chain.ARBITRUM_ONE: {},
     Chain.GNOSIS: {
         "pearl_alpha": "0xEE9F19b5DF06c7E8Bfc7B28745dcf944C504198A",
         "pearl_beta": "0xeF44Fb0842DDeF59D37f85D61A1eF492bbA6135d",
@@ -150,6 +132,7 @@ STAKING: t.Dict[Chain, t.Dict[str, str]] = {
         "modius_alpha_3": "0x9034D0413D122015710f1744A19eFb1d7c2CEB13",
         "modius_alpha_4": "0x8BcAdb2c291C159F9385964e5eD95a9887302862",
     },
+    Chain.POLYGON: {},
 }
 
 
@@ -167,37 +150,50 @@ DEFAULT_PRIORITY_MECH = {  # maps mech marketplace address to its default priori
 
 # ERC20 token addresses
 OLAS: t.Dict[Chain, str] = {
-    Chain.GNOSIS: "0xcE11e14225575945b8E6Dc0D4F2dD4C570f79d9f",
-    Chain.OPTIMISM: "0xFC2E6e6BCbd49ccf3A5f029c79984372DcBFE527",
+    Chain.ARBITRUM_ONE: "0x064F8B858C2A603e1b106a2039f5446D32dc81c1",
     Chain.BASE: "0x54330d28ca3357F294334BDC454a032e7f353416",
+    Chain.CELO: "0xaCFfAe8e57Ec6E394Eb1b41939A8CF7892DbDc51",
     Chain.ETHEREUM: "0x0001A500A6B18995B03f44bb040A5fFc28E45CB0",
+    Chain.GNOSIS: "0xcE11e14225575945b8E6Dc0D4F2dD4C570f79d9f",
     Chain.MODE: "0xcfD1D50ce23C46D3Cf6407487B2F8934e96DC8f9",
+    Chain.OPTIMISM: "0xFC2E6e6BCbd49ccf3A5f029c79984372DcBFE527",
+    Chain.POLYGON: "0xFEF5d947472e72Efbb2E388c730B7428406F2F95",
 }
 
 USDC: t.Dict[Chain, str] = {
-    Chain.GNOSIS: "0xDDAfbb505ad214D7b80b1f830fcCc89B60fb7A83",
-    Chain.OPTIMISM: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    Chain.ARBITRUM_ONE: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
     Chain.BASE: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    Chain.CELO: "0xcebA9300f2b948710d2653dD7B07f33A8B32118C",
     Chain.ETHEREUM: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    Chain.GNOSIS: "0xDDAfbb505ad214D7b80b1f830fcCc89B60fb7A83",
     Chain.MODE: "0xd988097fb8612cc24eeC14542bC03424c656005f",
+    Chain.OPTIMISM: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    Chain.POLYGON: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
 }
 
 WRAPPED_NATIVE_ASSET = {
-    Chain.GNOSIS: "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d",
-    Chain.OPTIMISM: "0x4200000000000000000000000000000000000006",
+    Chain.ARBITRUM_ONE: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
     Chain.BASE: "0x4200000000000000000000000000000000000006",
+    Chain.CELO: "0x471EcE3750Da237f93B8E339c536989b8978a438",  # Dual token
     Chain.ETHEREUM: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    Chain.GNOSIS: "0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d",
     Chain.MODE: "0x4200000000000000000000000000000000000006",
+    Chain.OPTIMISM: "0x4200000000000000000000000000000000000006",
     Chain.POLYGON: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
-    Chain.ARBITRUM_ONE: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
 }
 
 ERC20_TOKENS = [OLAS, USDC, WRAPPED_NATIVE_ASSET]
 
 DEFAULT_NEW_SAFE_FUNDS: t.Dict[Chain, t.Dict[str, int]] = {
+    Chain.ARBITRUM_ONE: {
+        ZERO_ADDRESS: int(1e15 / 4),
+    },
     Chain.BASE: {
         ZERO_ADDRESS: int(1e15 / 4),
     },
+    Chain.CELO: {
+        ZERO_ADDRESS: int(1e18),
+    },
     Chain.ETHEREUM: {
         ZERO_ADDRESS: int(1e15 / 4),
     },
@@ -210,21 +206,35 @@ DEFAULT_NEW_SAFE_FUNDS: t.Dict[Chain, t.Dict[str, int]] = {
     Chain.OPTIMISM: {
         ZERO_ADDRESS: int(1e15 / 4),
     },
+    Chain.POLYGON: {
+        ZERO_ADDRESS: int(1e18),
+    },
 }
 
 DEFAULT_MASTER_EOA_FUNDS = {
+    Chain.ARBITRUM_ONE: {ZERO_ADDRESS: 5_000_000_000_000_000},
     Chain.BASE: {ZERO_ADDRESS: 5_000_000_000_000_000},
+    Chain.CELO: {ZERO_ADDRESS: 1_500_000_000_000_000_000},
     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.OPTIMISM: {ZERO_ADDRESS: 5_000_000_000_000_000},
+    Chain.POLYGON: {ZERO_ADDRESS: 1_500_000_000_000_000_000},
 }
 
 EXPLORER_URL = {
+    Chain.ARBITRUM_ONE: {
+        "tx": "https://arbiscan.io/tx/{tx_hash}",
+        "address": "https://arbiscan.io/address/{address}",
+    },
     Chain.BASE: {
         "tx": "https://basescan.org/tx/{tx_hash}",
         "address": "https://basescan.org/address/{address}",
     },
+    Chain.CELO: {
+        "tx": "https://celoscan.io/tx/{tx_hash}",
+        "address": "https://celoscan.io/address/{address}",
+    },
     Chain.ETHEREUM: {
         "tx": "https://etherscan.io/tx/{tx_hash}",
         "address": "https://etherscan.io/address/{address}",
@@ -234,13 +244,17 @@ EXPLORER_URL = {
         "address": "https://gnosisscan.io/address/{address}",
     },
     Chain.MODE: {
-        "tx": "https://modescan.io/tx/{tx_hash}",
-        "address": "https://modescan.io/address/{address}",
+        "tx": "https://explorer.mode.network/tx/{tx_hash}",
+        "address": "https://explorer.mode.network/address/{address}",
     },
     Chain.OPTIMISM: {
         "tx": "https://optimistic.etherscan.io/tx/{tx_hash}",
         "address": "https://optimistic.etherscan.io/address/{address}",
     },
+    Chain.POLYGON: {
+        "tx": "https://polygonscan.com/tx/{tx_hash}",
+        "address": "https://polygonscan.com/address/{address}",
+    },
 }
 
 

operate/migration.py

@@ -29,11 +29,10 @@ from time import time
 
 from aea_cli_ipfs.ipfs_utils import IPFSTool
 
-from operate.constants import ZERO_ADDRESS
+from operate.constants import USER_JSON, ZERO_ADDRESS
 from operate.operate_types import Chain, LedgerType
 from operate.services.manage import ServiceManager
 from operate.services.service import (
-    DEFAULT_TRADER_ENV_VARS,
     NON_EXISTENT_MULTISIG,
     SERVICE_CONFIG_PREFIX,
     SERVICE_CONFIG_VERSION,
@@ -43,11 +42,67 @@ from operate.utils import create_backup
 from operate.wallet.master import LEDGER_TYPE_TO_WALLET_CLASS, MasterWalletManager
 
 
+DEFAULT_TRADER_ENV_VARS = {
+    "GNOSIS_LEDGER_RPC": {
+        "name": "Gnosis ledger RPC",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "STAKING_CONTRACT_ADDRESS": {
+        "name": "Staking contract address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_MARKETPLACE_CONFIG": {
+        "name": "Mech marketplace configuration",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_ACTIVITY_CHECKER_CONTRACT": {
+        "name": "Mech activity checker contract",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_CONTRACT_ADDRESS": {
+        "name": "Mech contract address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "MECH_REQUEST_PRICE": {
+        "name": "Mech request price",
+        "description": "",
+        "value": "10000000000000000",
+        "provision_type": "computed",
+    },
+    "USE_MECH_MARKETPLACE": {
+        "name": "Use Mech marketplace",
+        "description": "",
+        "value": "False",
+        "provision_type": "computed",
+    },
+    "REQUESTER_STAKING_INSTANCE_ADDRESS": {
+        "name": "Requester staking instance address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+    "PRIORITY_MECH_ADDRESS": {
+        "name": "Priority Mech address",
+        "description": "",
+        "value": "",
+        "provision_type": "computed",
+    },
+}
+
+
 class MigrationManager:
     """MigrationManager"""
 
-    # TODO Backport here migration for services/config.json, etc.
-
     def __init__(
         self,
         home: Path,
@@ -62,12 +117,12 @@ class MigrationManager:
         """Log directories present in `path`."""
         directories = [f"  - {str(p)}" for p in path.iterdir() if p.is_dir()]
         directories_str = "\n".join(directories)
-        self.logger.info(f"Directories in {path}\n: {directories_str}")
+        self.logger.info(f"Directories in {path}:\n{directories_str}")
 
     def migrate_user_account(self) -> None:
         """Migrates user.json"""
 
-        path = self._path / "user.json"
+        path = self._path / USER_JSON
         if not path.exists():
             return
 
@@ -102,18 +157,22 @@ class MigrationManager:
 
         self.logger.info("Migrating wallet configs done.")
 
-    @staticmethod
     def _migrate_service(  # pylint: disable=too-many-statements,too-many-locals
+        self,
         path: Path,
     ) -> bool:
         """Migrate the JSON file format if needed."""
 
         if not path.is_dir():
+            self.logger.warning(f"Service config path {path} is not a directory.")
             return False
 
         if not path.name.startswith(SERVICE_CONFIG_PREFIX) and not path.name.startswith(
             "bafybei"
         ):
+            self.logger.warning(
+                f"Service config path {path} is not a valid service config."
+            )
             return False
 
         if path.name.startswith("bafybei"):
@@ -155,6 +214,10 @@ class MigrationManager:
         if version == SERVICE_CONFIG_VERSION:
             return False
 
+        self.logger.info(
+            f"Migrating service config in {path} from version {version} to {SERVICE_CONFIG_VERSION}..."
+        )
+
         # Migration steps for older versions
         if version == 0:
             new_data = {
@@ -344,13 +407,9 @@ class MigrationManager:
         paths = list(service_manager.path.iterdir())
         for path in paths:
             try:
-                if path.name.startswith(SERVICE_CONFIG_PREFIX) or path.name.startswith(
-                    "bafybei"
-                ):
-                    self.logger.info(f"migrate_service_configs {str(path)}")
-                    migrated = self._migrate_service(path)
-                    if migrated:
-                        self.logger.info(f"Folder {str(path)} has been migrated.")
+                migrated = self._migrate_service(path)
+                if migrated:
+                    self.logger.info(f"Folder {str(path)} has been migrated.")
             except Exception as e:  # pylint: disable=broad-except
                 self.logger.error(
                     f"Failed to migrate service: {path.name}. Exception {e}: {traceback.format_exc()}"

operate/operate_types.py

@@ -154,6 +154,8 @@ class ContractAddresses(TypedDict):
     service_registry_token_utility: str
     gnosis_safe_proxy_factory: str
     gnosis_safe_same_address_multisig: str
+    safe_multisig_with_recovery_module: str
+    recovery_module: str
     multisend: str
 
 

operate/quickstart/reset_password.py

@@ -21,6 +21,7 @@
 from typing import TYPE_CHECKING
 
 from operate.account.user import UserAccount
+from operate.constants import USER_JSON
 from operate.operate_types import LedgerType
 from operate.quickstart.run_service import ask_confirm_password
 from operate.quickstart.utils import ask_or_get_from_env, print_section, print_title
@@ -36,7 +37,7 @@ def reset_password(operate: "OperateApp") -> None:
     print_title("Reset your password")
 
     # check if agent was started before
-    if not (operate._path / "user.json").exists():
+    if not (operate._path / USER_JSON).exists():
         print("No previous agent setup found. Exiting.")
         return
 
@@ -57,7 +58,7 @@ def reset_password(operate: "OperateApp") -> None:
     print("Resetting password of user account...")
     UserAccount.new(
         password=old_password,
-        path=operate._path / "user.json",
+        path=operate._path / USER_JSON,
     ).update(
         old_password=old_password,
         new_password=new_password,

operate/quickstart/run_service.py

@@ -34,7 +34,12 @@ 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
+from operate.constants import (
+    IPFS_ADDRESS,
+    NO_STAKING_PROGRAM_ID,
+    OPERATE_HOME,
+    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
@@ -453,7 +458,7 @@ def ask_password_if_needed(operate: "OperateApp") -> None:
         password = ask_confirm_password()
         UserAccount.new(
             password=password,
-            path=operate._path / "user.json",
+            path=operate._path / USER_JSON,
         )
     else:
         _password = None