Merge pull request #11 from valory-xyz/fix/fund-ops

Fix/fund ops

Author: 0xArdi

README.md

@@ -85,7 +85,11 @@ Once the command has completed, i.e. the service is running, you can see the liv
 ```bash
 docker logs optimus_abci_0 --follow
 ```
+Execute the report command to view a summary of the service status:
 
+```bash
+poetry run python report.py
+```
 To inspect the tree state transition of the current run of the agent run:
 ```bash
 poetry run autonomy analyse logs --from-dir .optimus/services/[service-hash]/deployment/persistent_data/logs/  --agent aea_0 --fsm --reset-db

operate/services/manage.py

@@ -33,6 +33,7 @@
 from aea.helpers.base import IPFSHash
 from aea.helpers.logging import setup_logger
 from autonomy.chain.base import registry_contracts
+from pycparser.ply.yacc import token
 
 from operate.keys import Key, KeysManager
 from operate.ledger import PUBLIC_RPCS
@@ -475,7 +476,7 @@ def deploy_service_onchain_from_safe_single_chain(  # pylint: disable=too-many-s
         is_update = (
             (not is_first_mint)
             and (on_chain_hash is not None)
-            and (on_chain_hash != service.hash or current_agent_id != agent_id)
+            and (current_agent_id != agent_id)
         )
 
         if is_update:
@@ -1102,6 +1103,73 @@ def fund_service(  # pylint: disable=too-many-arguments
                 rpc=rpc or ledger_config.rpc,
             )
 
+    def fund_service_erc20(  # pylint: disable=too-many-arguments
+        self,
+        hash: str,
+        token: str,
+        rpc: t.Optional[str] = None,
+        agent_topup: t.Optional[float] = None,
+        safe_topup: t.Optional[float] = None,
+        agent_fund_threshold: t.Optional[float] = None,
+        safe_fund_treshold: t.Optional[float] = None,
+        from_safe: bool = True,
+        chain_id: str = "10",
+    ) -> None:
+        """Fund service if required."""
+        service = self.load_or_create(hash=hash)
+        chain_config = service.chain_configs[chain_id]
+        ledger_config = chain_config.ledger_config
+        chain_data = chain_config.chain_data
+        wallet = self.wallet_manager.load(ledger_config.type)
+        ledger_api = wallet.ledger_api(chain_type=ledger_config.chain, rpc=rpc or ledger_config.rpc)
+        agent_fund_threshold = (
+            agent_fund_threshold
+            or chain_data.user_params.fund_requirements.agent
+        )
+
+        for key in service.keys:
+            agent_balance = ledger_api.get_balance(address=key.address)
+            self.logger.info(f"Agent {key.address} balance: {agent_balance}")
+            self.logger.info(f"Required balance: {agent_fund_threshold}")
+            if agent_balance < agent_fund_threshold:
+                self.logger.info("Funding agents")
+                to_transfer = (
+                    agent_topup
+                    or chain_data.user_params.fund_requirements.agent
+                )
+                self.logger.info(f"Transferring {to_transfer} units to {key.address}")
+                wallet.transfer_erc20(
+                    token=token,
+                    to=key.address,
+                    amount=int(to_transfer),
+                    chain_type=ledger_config.chain,
+                    from_safe=from_safe,
+                    rpc=rpc or ledger_config.rpc,
+                )
+
+        safe_balance = registry_contracts.erc20.get_instance(ledger_api, token).functions.balanceOf(chain_data.multisig).call()
+        safe_fund_treshold = (
+            safe_fund_treshold or chain_data.user_params.fund_requirements.safe
+        )
+        self.logger.info(f"Safe {chain_data.multisig} balance: {safe_balance}")
+        self.logger.info(f"Required balance: {safe_fund_treshold}")
+        if safe_balance < safe_fund_treshold:
+            self.logger.info("Funding safe")
+            to_transfer = (
+                    safe_topup or chain_data.user_params.fund_requirements.safe
+            )
+            self.logger.info(
+                f"Transferring {to_transfer} units to {chain_data.multisig}"
+            )
+            wallet.transfer_erc20(
+                token=token,
+                to=t.cast(str, chain_data.multisig),
+                amount=int(to_transfer),
+                chain_type=ledger_config.chain,
+                rpc=rpc or ledger_config.rpc,
+            )
+
+
     async def funding_job(
         self,
         hash: str,

operate/services/protocol.py

@@ -19,11 +19,11 @@ operate = "operate.cli:main"
 
 [tool.poetry.dependencies]
 python = "<3.12,>=3.9"
-open-autonomy = "==0.14.14.post2"
-open-aea-ledger-cosmos = "==1.53.0"
-open-aea-ledger-ethereum = "==1.53.0"
-open-aea-ledger-ethereum-flashbots = "==1.53.0"
-open-aea-cli-ipfs = "==1.53.0"
+open-autonomy = "==0.16.0"
+open-aea-ledger-cosmos = "==1.56.0"
+open-aea-ledger-ethereum = "==1.56.0"
+open-aea-ledger-ethereum-flashbots = "==1.56.0"
+open-aea-cli-ipfs = "==1.56.0"
 clea = "==0.1.0rc4"
 cytoolz = "==0.12.3"
 docker = "6.1.2"

operate/utils/gnosis.py

@@ -1,215 +1,149 @@
+# report.py
 import json
 from datetime import datetime
-from pathlib import Path
-from web3 import Web3
-import docker
-# Import necessary functions and constants from run_service.py
+import logging
+from decimal import Decimal, getcontext
+
 from run_service import (
     get_local_config,
     get_service_template,
-    wei_to_token,
-    get_erc20_balance,
     CHAIN_ID_TO_METADATA,
-    USDC_ADDRESS,
     OPERATE_HOME,
-    OptimusConfig,
 )
 
-# Import necessary functions from wallet_info.py
-from wallet_info import save_wallet_info
-from staking_report import staking_report
-# Existing imports and functions...
-OUTPUT_WIDTH = 80
-
-
-class ColorCode:
-    """Terminal color codes"""
-
-    GREEN = "\033[92m"
-    RED = "\033[91m"
-    YELLOW = "\033[93m"
-    RESET = "\033[0m"
-
-
-def _color_string(text: str, color_code: str) -> str:
-    return f"{color_code}{text}{ColorCode.RESET}"
-
-
-def _color_bool(
-    is_true: bool, true_string: str = "True", false_string: str = "False"
-) -> str:
-    if is_true:
-        return _color_string(true_string, ColorCode.GREEN)
-    return _color_string(false_string, ColorCode.RED)
-
-
-def _color_percent(p: float, multiplier: float = 100, symbol: str = "%") -> str:
-    if p >= 0:
-        return f"{p*multiplier:.2f} {symbol}"
-    return _color_string(f"{p*multiplier:.2f} {symbol}", ColorCode.RED)
-
-def _print_section_header(header: str) -> None:
-    print("\n\n" + header)
-    print("=" * OUTPUT_WIDTH)
-
-
-def _print_subsection_header(header: str) -> None:
-    print("\n" + header)
-    print("-" * OUTPUT_WIDTH)
-
-
-def _print_status(key: str, value: str, message: str = "") -> None:
-    print(f"{key:<30}{value:<10} {message or ''}")
-
-def _get_agent_status() -> str:
-    client = docker.from_env()
-    optmius_abci_container = (
-        client.containers.get("optimus_abci_0")
-        if "optimus_abci_0" in [c.name for c in client.containers.list()]
-        else None
-    )
-    is_running = optmius_abci_container 
-    return _color_bool(is_running, "Running", "Stopped")    
-
-def wei_to_unit(wei: int) -> float:
-    """Convert Wei to unit."""
-    return wei / 1e18
-
+from utils import (
+    _print_section_header,
+    _print_subsection_header,
+    _print_status,
+    wei_to_eth,
+    _warning_message,
+    get_chain_name,
+    load_operator_address,
+    validate_config,
+    _get_agent_status,
+)
 
-def wei_to_token(wei: int, token: str = "xDAI") -> str:
-    """Convert Wei to token."""
-    return f"{wei_to_unit(wei):.2f} {token}"
+from wallet_info import save_wallet_info, load_config as load_wallet_config
+from staking_report import staking_report
 
-def wei_to_olas(wei: int) -> str:
-    """Converts and formats wei to WxDAI."""
-    return "{:.2f} OLAS".format(wei_to_unit(wei))
+# Set decimal precision
+getcontext().prec = 18
 
-def _warning_message(current_value: int, threshold: int = 0, message: str = "") -> str:
-    default_message = _color_string(
-        f"- Balance too low. Threshold is {wei_to_unit(threshold):.2f}.",
-        ColorCode.YELLOW,
-    )
-    if current_value < threshold:
-        return (
-            _color_string(f"{message}", ColorCode.YELLOW)
-            if message
-            else default_message
-        )
-    return ""
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(message)s')
 
 def load_wallet_info():
     save_wallet_info()
     file_path = OPERATE_HOME / "wallets" / "wallet_info.json"
-    with open(file_path, "r") as f:
-        return json.load(f)
-
-def load_config():
-    optimus_config = get_local_config()
-    service_template = get_service_template(optimus_config)
-    service_hash = service_template["hash"]
-
-    config_path = OPERATE_HOME / f"services/{service_hash}/config.json"
-    with open(config_path, "r") as f:
-        return json.load(f)
-
-def load_operator_address():
-    ethereum_json_path = OPERATE_HOME / "wallets" / "ethereum.json"
-    with open(ethereum_json_path, "r") as f:
-        ethereum_data = json.load(f)
-    # Pick the address from safes where safe chain is 4
-    return ethereum_data["safes"]["4"]
-
-def check_service_status():
-    # Placeholder for actual status checking logic
-    return "Stopped"
-
-def wei_to_eth(wei_value):
-    return Web3.from_wei(wei_value, 'ether')
+    try:
+        with open(file_path, "r") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        print(f"Error: Wallet info file not found at {file_path}")
+        return {}
+    except json.JSONDecodeError:
+        print("Error: Wallet info file contains invalid JSON.")
+        return {}
 
 def generate_report():
-    # First, update the wallet info
-    wallet_info = load_wallet_info()
-    
-    operator_address = load_operator_address()
-    config = load_config()
-    # Service Report Header
-    print("")
-    print("==============")
-    print("Optimus Service report")
-    print("Generated on: ", datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
-    print("==============")
-    # Now load the updated wallet info
-
-
-    staking_report(config)
-    home_chain_id = config.get("home_chain_id")
-    service_id = config["chain_configs"][home_chain_id]["chain_data"]["token"]
-
-
-
-    # Service Section
-    _print_section_header("Service")
-    _print_status("ID", str(service_id))
-
-    # Agent Section
-    agent_status = _get_agent_status()
-    _print_subsection_header("Agent")
-    _print_status("Status (on this machine)", agent_status)
-    _print_status("Address", wallet_info['main_wallet_address'])
-    # _print_status(
-    #     " Balance",
-    #     f"{wei_to_xdai(agent_xdai)} {_warning_message(agent_xdai, AGENT_XDAI_BALANCE_THRESHOLD)}",
-    # )  #to-do warning message and threshold
-    
-    
-    # Agent balances across chains
-    for chain_id, chain_config in config["chain_configs"].items():
-        chain_name = CHAIN_ID_TO_METADATA[int(chain_id)]["name"]
-        balance_info = wallet_info['main_wallet_balances'].get(chain_name, {})
-        _print_status(f"{chain_name} Balance",f"{balance_info.get('balance_formatted', 'N/A')}")
-        # Get the agent threshold from the config
-        ######TO-DO get the agent threshold from the config
-        # agent_threshold_wei = chain_config["chain_data"]["user_params"]["fund_requirements"]["agent"]
-        # agent_threshold = f"{wei_to_eth(agent_threshold_wei):.3f} ETH"
-        
-        # # Check for low balance
-        # current_balance = float(balance_info.get('balance_formatted', '0').split()[0])
-        # if current_balance < float(agent_threshold.split()[0]):
-        #     report.append(f"Agent - Balance too low. Threshold is {agent_threshold}.")
-    
-    # report.append("")
-
-    # # Safe Section
-    _print_subsection_header("Safe")
-    for chain_id, chain_config in config["chain_configs"].items():
-        chain_name = CHAIN_ID_TO_METADATA[int(chain_id)]["name"]
-        safe_info = wallet_info['safe_balances'].get(chain_name, {})
-        _print_status(f"Address ({chain_name})",f"{safe_info.get('address', 'N/A')}")
-        _print_status(f"{safe_info.get('token', 'ETH')} Balance",f"{safe_info.get('balance_formatted', 'N/A')}")
-        
-        if 'usdc_balance' in safe_info:
-            _print_status("USDC Balance",safe_info['usdc_balance_formatted'])
-        print("              ")
-        ######  TO-DO Low balance check
-    #     # Get the safe threshold from the config
-    #     safe_threshold_wei = chain_config["chain_data"]["user_params"]["fund_requirements"]["safe"]
-    #     safe_threshold = f"{wei_to_eth(safe_threshold_wei):.3f} ETH"
-        
-    #     # Check for low balance
-    #     current_balance = float(safe_info.get('balance_formatted', '0').split()[0])
-    #     if current_balance < float(safe_threshold.split()[0]):
-    #         report.append(f"Safe - Balance too low. Threshold is {safe_threshold}.")
-        
-    #     report.append("")
-
-    # # Owner/Operator Section
-    _print_subsection_header("Owner/Operator")
-    _print_status("Address", operator_address)
-    for chain_name, balance_info in wallet_info['main_wallet_balances'].items():
-        _print_status(f"{chain_name} Balance",balance_info['balance_formatted'])
-    #     report.append(f"{chain_name} Balance           {balance_info['balance_formatted']}")
-
-
+    try:
+        # First, update the wallet info
+        wallet_info = load_wallet_info()
+        if not wallet_info:
+            print("Error: Wallet info is empty.")
+            return
+
+        operator_address = load_operator_address(OPERATE_HOME)
+        if not operator_address:
+            print("Error: Operator address could not be loaded.")
+            return
+
+        config = load_wallet_config()
+        if not config:
+            print("Error: Config is empty.")
+            return
+
+        if not validate_config(config):
+            return
+
+        # Service Report Header
+        print("")
+        print("==============")
+        print("Optimus Service Report")
+        print("Generated on: ", datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
+        print("==============")
+
+        staking_report(config)
+        home_chain_id = config.get("home_chain_id")
+        service_id = config.get("chain_configs", {}).get(str(home_chain_id), {}).get("chain_data", {}).get("token")
+        if not service_id:
+            print(f"Error: 'token' not found in chain data for chain ID {home_chain_id}.")
+            return
+
+        # Service Section
+        _print_section_header("Service")
+        _print_status("ID", str(service_id))
+
+        # Agent Section
+        agent_status = _get_agent_status()
+        _print_subsection_header("Agent")
+        _print_status("Status (on this machine)", agent_status)
+        _print_status("Address", wallet_info.get('main_wallet_address', 'N/A'))
+
+        for chain_id, chain_config in config.get("chain_configs", {}).items():
+            chain_name = get_chain_name(chain_id, CHAIN_ID_TO_METADATA)
+            balance_info = wallet_info.get('main_wallet_balances', {}).get(chain_name, {})
+            balance_formatted = balance_info.get('balance_formatted', 'N/A')
+            _print_status(f"{chain_name} Balance", balance_formatted)
+
+            # Low balance check
+            agent_threshold_wei = chain_config.get("chain_data", {}).get("user_params", {}).get("fund_requirements", {}).get("agent")
+            if agent_threshold_wei:
+                agent_threshold_eth = wei_to_eth(agent_threshold_wei)
+                current_balance_str = balance_formatted.split()[0]
+                try:
+                    current_balance = Decimal(current_balance_str)
+                    if current_balance < agent_threshold_eth:
+                        warning_msg = _warning_message(current_balance, agent_threshold_eth, f"Balance below threshold of {agent_threshold_eth:.2f} ETH")
+                        _print_status("Warning", warning_msg)
+                except (ValueError, Exception):
+                    print(f"Warning: Could not parse balance '{balance_formatted}' for chain '{chain_name}'.")
+
+        # Safe Section
+        _print_subsection_header("Safe")
+        safe_balances = wallet_info.get('safe_balances', {})
+        for chain_id, chain_config in config.get("chain_configs", {}).items():
+            chain_name = get_chain_name(chain_id, CHAIN_ID_TO_METADATA)
+            safe_info = safe_balances.get(chain_name, {})
+            _print_status(f"Address ({chain_name})", safe_info.get('address', 'N/A'))
+            _print_status(f"{safe_info.get('token', 'ETH')} Balance", safe_info.get('balance_formatted', 'N/A'))
+
+            # Check for USDC balance on Ethereum Mainnet
+            if chain_id == "1":
+                usdc_balance_formatted = safe_info.get('usdc_balance_formatted', 'N/A')
+                _print_status("USDC Balance", usdc_balance_formatted)
+            
+            # Low balance check
+            safe_threshold_wei = chain_config.get("chain_data", {}).get("user_params", {}).get("fund_requirements", {}).get("safe")
+            if safe_threshold_wei:
+                safe_threshold_eth = wei_to_eth(safe_threshold_wei)
+                balance_str = safe_info.get('balance_formatted', '0').split()[0]
+                try:
+                    current_balance = Decimal(balance_str)
+                    if current_balance < safe_threshold_eth:
+                        warning_msg = _warning_message(current_balance, safe_threshold_eth, f"Balance below threshold of {safe_threshold_eth:.2f} ETH")
+                        _print_status("Warning", warning_msg)
+                except (ValueError, Exception):
+                    print(f"Warning: Could not parse balance '{balance_str}' for chain '{chain_name}'.")
+            print()
+        # Owner/Operator Section
+        _print_subsection_header("Owner/Operator")
+        _print_status("Address", operator_address)
+        for chain_name, balance_info in wallet_info.get('main_wallet_balances', {}).items():
+            _print_status(f"{chain_name} Balance", balance_info.get('balance_formatted', 'N/A'))
+
+    except Exception as e:
+        print(f"An unexpected error occurred in generate_report: {e}")
 
 if __name__ == "__main__":
     generate_report()

operate/wallet/master.py

@@ -0,0 +1,115 @@
+# utils.py
+import json
+from pathlib import Path
+from datetime import datetime
+from decimal import Decimal, getcontext
+import logging
+import docker
+from web3 import Web3
+from web3.middleware import geth_poa_middleware
+from enum import Enum
+
+# Set decimal precision
+getcontext().prec = 18
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(message)s')
+
+# Terminal color codes
+class ColorCode:
+    GREEN = "\033[92m"
+    RED = "\033[91m"
+    YELLOW = "\033[93m"
+    RESET = "\033[0m"
+
+class StakingState(Enum):
+    """Staking state enumeration for the staking."""
+    UNSTAKED = 0
+    STAKED = 1
+    EVICTED = 2
+
+def _color_string(text: str, color_code: str) -> str:
+    return f"{color_code}{text}{ColorCode.RESET}"
+
+def _color_bool(is_true: bool, true_string: str = "True", false_string: str = "False") -> str:
+    if is_true:
+        return _color_string(true_string, ColorCode.GREEN)
+    return _color_string(false_string, ColorCode.RED)
+
+def _warning_message(current_value: Decimal, threshold: Decimal, message: str = "") -> str:
+    default_message = _color_string(
+        f"- Value too low. Threshold is {threshold:.2f}.",
+        ColorCode.YELLOW,
+    )
+    if current_value < threshold:
+        return _color_string(message or default_message, ColorCode.YELLOW)
+    return ""
+
+def _print_section_header(header: str, output_width: int = 80) -> None:
+    print("\n\n" + header)
+    print("=" * output_width)
+
+def _print_subsection_header(header: str, output_width: int = 80) -> None:
+    print("\n" + header)
+    print("-" * output_width)
+
+def _print_status(key: str, value: str, message: str = "") -> None:
+    line = f"{key:<30}{value:<20}"
+    if message:
+        line += f"{message}"
+    print(line)
+
+def wei_to_unit(wei: int) -> Decimal:
+    """Convert Wei to unit."""
+    return Decimal(wei) / Decimal(1e18)
+
+def wei_to_token(wei: int, token: str = "xDAI") -> str:
+    """Convert Wei to token."""
+    return f"{wei_to_unit(wei):.2f} {token}"
+
+def wei_to_olas(wei: int) -> str:
+    """Converts and formats wei to OLAS."""
+    return "{:.2f} OLAS".format(wei_to_unit(wei))
+
+def wei_to_eth(wei_value):
+    return Decimal(wei_value) / Decimal(1e18)
+
+def get_chain_name(chain_id, chain_id_to_metadata):
+    return chain_id_to_metadata.get(int(chain_id), {}).get("name", f"Chain {chain_id}")
+
+def load_operator_address(operate_home):
+    ethereum_json_path = operate_home / "wallets" / "ethereum.json"
+    try:
+        with open(ethereum_json_path, "r") as f:
+            ethereum_data = json.load(f)
+        operator_address = ethereum_data.get("safes", {}).get("4")
+        if not operator_address:
+            print("Error: Operator address not found for chain ID 4 in the wallet file.")
+            return None
+        return operator_address
+    except FileNotFoundError:
+        print(f"Error: Ethereum wallet file not found at {ethereum_json_path}")
+        return None
+    except json.JSONDecodeError:
+        print("Error: Ethereum wallet file contains invalid JSON.")
+        return None
+
+def validate_config(config):
+    required_keys = ['home_chain_id', 'chain_configs']
+    for key in required_keys:
+        if key not in config:
+            print(f"Error: '{key}' is missing in the configuration.")
+            return False
+    return True
+
+def _get_agent_status() -> str:
+    try:
+        client = docker.from_env()
+        container = client.containers.get("optimus_abci_0")
+        is_running = container.status == "running"
+        return _color_bool(is_running, "Running", "Stopped")
+    except docker.errors.NotFound:
+        return _color_string("Not Found", ColorCode.RED)
+    except docker.errors.DockerException as e:
+        print(f"Error: Docker exception occurred - {str(e)}")
+        return _color_string("Error", ColorCode.RED)

poetry.lock

@@ -1,41 +1,83 @@
+# wallet_info.py
 import json
 from pathlib import Path
 from web3 import Web3
 from web3.middleware import geth_poa_middleware
-from decimal import Decimal
+from decimal import Decimal, getcontext
+import logging
+
 from run_service import (
     get_local_config,
     get_service_template,
-    wei_to_token,
-    get_erc20_balance,
     CHAIN_ID_TO_METADATA,
     USDC_ADDRESS,
     OPERATE_HOME,
-    OptimusConfig,
 )
 
+from utils import (
+    get_chain_name,
+    load_operator_address,
+    validate_config,
+    wei_to_unit,
+    wei_to_eth,
+    ColorCode,
+)
 
+# Set decimal precision
+getcontext().prec = 18
 
-USDC_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
-USDC_ABI = [{"constant":True,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"type":"function"}]
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(message)s')
 
-def load_config():
-    optimus_config = get_local_config()
-    service_template = get_service_template(optimus_config)
-    service_hash = service_template["hash"]
+# Ensure USDC_ADDRESS is set (if not, define it here)
+USDC_ADDRESS = USDC_ADDRESS or "0xA0b86991c6218b36c1d19d4a2e9Eb0cE3606eB48"  # Ethereum Mainnet USDC address
 
-    config_path = OPERATE_HOME / f"services/{service_hash}/config.json"
-    with open(config_path, "r") as f:
-        return json.load(f)
+USDC_ABI = [{
+    "constant": True,
+    "inputs": [{"name": "_owner", "type": "address"}],
+    "name": "balanceOf",
+    "outputs": [{"name": "balance", "type": "uint256"}],
+    "type": "function"
+}]
+
+def load_config():
+    try:
+        optimus_config = get_local_config()
+        service_template = get_service_template(optimus_config)
+        service_hash = service_template.get("hash")
+        if not service_hash:
+            print("Error: Service hash not found in service template.")
+            return {}
+        config_path = OPERATE_HOME / f"services/{service_hash}/config.json"
+        try:
+            with open(config_path, "r") as f:
+                return json.load(f)
+        except FileNotFoundError:
+            print(f"Error: Config file not found at {config_path}")
+            return {}
+        except json.JSONDecodeError:
+            print("Error: Config file contains invalid JSON.")
+            return {}
+    except Exception as e:
+        print(f"An error occurred while loading the config: {e}")
+        return {}
 
 def get_balance(web3, address):
-    balance = web3.eth.get_balance(address)
-    return float(Web3.from_wei(balance, 'ether'))
+    try:
+        balance = web3.eth.get_balance(address)
+        return Decimal(Web3.from_wei(balance, 'ether'))
+    except Exception as e:
+        print(f"Error getting balance for address {address}: {e}")
+        return Decimal(0)
 
 def get_usdc_balance(web3, address):
-    usdc_contract = web3.eth.contract(address=USDC_ADDRESS, abi=USDC_ABI)
-    balance = usdc_contract.functions.balanceOf(address).call()
-    return float(balance) / 1e6  # USDC has 6 decimal places
+    try:
+        usdc_contract = web3.eth.contract(address=USDC_ADDRESS, abi=USDC_ABI)
+        balance = usdc_contract.functions.balanceOf(address).call()
+        return Decimal(balance) / Decimal(1e6)  # USDC has 6 decimal places
+    except Exception as e:
+        print(f"Error getting USDC balance for address {address}: {e}")
+        return Decimal(0)
 
 class DecimalEncoder(json.JSONEncoder):
     def default(self, o):
@@ -45,67 +87,92 @@ def default(self, o):
 
 def save_wallet_info():
     config = load_config()
-    main_wallet_address = config['keys'][0]['address']
-    
+    if not config:
+        print("Error: Configuration could not be loaded.")
+        return
+
+    main_wallet_address = config.get('keys', [{}])[0].get('address')
+    if not main_wallet_address:
+        print("Error: Main wallet address not found in configuration.")
+        return
+
     main_balances = {}
     safe_balances = {}
-    
-    for chain_id, chain_config in config['chain_configs'].items():
-        rpc_url = chain_config['ledger_config']['rpc']
-        web3 = Web3(Web3.HTTPProvider(rpc_url))
-        web3.middleware_onion.inject(geth_poa_middleware, layer=0)
-        
-        chain_name = {
-            "1": "Ethereum Mainnet",
-            "10": "Optimism",
-            "8453": "Base"
-        }.get(chain_id, f"Chain {chain_id}")
-        
-        # Get main wallet balance
-        main_balance = get_balance(web3, main_wallet_address)
-        main_balances[chain_name] = {
-            "token": "ETH",
-            "balance": main_balance,
-            "balance_formatted": f"{main_balance:.6f} ETH"
-        }
-        
-        # Get Safe balance
-        safe_address = chain_config['chain_data']['multisig']
-        safe_balance = get_balance(web3, safe_address)
-        safe_balances[chain_name] = {
-            "address": safe_address,
-            "token": "ETH",
-            "balance": safe_balance,
-            "balance_formatted": f"{safe_balance:.6f} ETH"
-        }
-        
-        # Get USDC balance for Ethereum Mainnet
-        if chain_id == "1":
-            usdc_balance = get_usdc_balance(web3, safe_address)
-            safe_balances[chain_name]["usdc_balance"] = usdc_balance
-            safe_balances[chain_name]["usdc_balance_formatted"] = f"{usdc_balance:.2f} USDC"
-    
+
+    for chain_id, chain_config in config.get('chain_configs', {}).items():
+        rpc_url = chain_config.get('ledger_config', {}).get('rpc')
+        if not rpc_url:
+            print(f"Error: RPC URL not found for chain ID {chain_id}.")
+            continue
+
+        try:
+            web3 = Web3(Web3.HTTPProvider(rpc_url))
+            if chain_id != "1":  # Ethereum Mainnet
+                web3.middleware_onion.inject(geth_poa_middleware, layer=0)
+
+            chain_name = get_chain_name(chain_id, CHAIN_ID_TO_METADATA)
+
+            # Get main wallet balance
+            main_balance = get_balance(web3, main_wallet_address)
+            main_balances[chain_name] = {
+                "token": "ETH",
+                "balance": main_balance,
+                "balance_formatted": f"{main_balance:.6f} ETH"
+            }
+
+            # Get Safe balance
+            safe_address = chain_config.get('chain_data', {}).get('multisig')
+            if not safe_address:
+                print(f"Error: Safe address not found for chain ID {chain_id}.")
+                continue
+
+            safe_balance = get_balance(web3, safe_address)
+            safe_balances[chain_name] = {
+                "address": safe_address,
+                "token": "ETH",
+                "balance": safe_balance,
+                "balance_formatted": f"{safe_balance:.6f} ETH"
+            }
+
+            # Get USDC balance for Ethereum Mainnet (chain ID 1)
+            if chain_id == "1":
+                usdc_balance = get_usdc_balance(web3, safe_address)
+                safe_balances[chain_name]["usdc_balance"] = usdc_balance
+                safe_balances[chain_name]["usdc_balance_formatted"] = f"{usdc_balance:.2f} USDC"
+
+        except Exception as e:
+            print(f"An error occurred while processing chain ID {chain_id}: {e}")
+            continue
+
     wallet_info = {
         "main_wallet_address": main_wallet_address,
         "main_wallet_balances": main_balances,
-        "safe_addresses": {chain_id: config['chain_configs'][chain_id]['chain_data']['multisig'] for chain_id in config['chain_configs']},
+        "safe_addresses": {
+            chain_id: chain_config.get('chain_data', {}).get('multisig', 'N/A')
+            for chain_id, chain_config in config.get('chain_configs', {}).items()
+        },
         "safe_balances": safe_balances,
         "chain_configs": {
             chain_id: {
-                "rpc": chain_config['ledger_config']['rpc'],
-                "multisig": chain_config['chain_data']['multisig'],
-                "token": chain_config['chain_data']['token'],
-                "fund_requirements": chain_config['chain_data']['user_params']['fund_requirements']
+                "rpc": chain_config.get('ledger_config', {}).get('rpc'),
+                "multisig": chain_config.get('chain_data', {}).get('multisig'),
+                "token": chain_config.get('chain_data', {}).get('token'),
+                "fund_requirements": chain_config.get('chain_data', {}).get('user_params', {}).get('fund_requirements')
             }
-            for chain_id, chain_config in config['chain_configs'].items()
+            for chain_id, chain_config in config.get('chain_configs', {}).items()
         }
     }
-    
+
     file_path = OPERATE_HOME / "wallets" / "wallet_info.json"
-    with open(file_path, "w") as f:
-        json.dump(wallet_info, f, indent=2, cls=DecimalEncoder)
-    
-    print(f"Wallet information saved to {file_path}")
+    try:
+        with open(file_path, "w") as f:
+            json.dump(wallet_info, f, indent=2, cls=DecimalEncoder)
+        print(f"Wallet info saved to {file_path}")
+    except Exception as e:
+        print(f"Error saving wallet info to {file_path}: {e}")
 
 if __name__ == "__main__":
-    save_wallet_info()
+    try:
+        save_wallet_info()
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")