iwa 0.0.0__py3-none-any.whl → 0.0.1a2__py3-none-any.whl

iwa/tools/check_profile.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""Tool to check the active Tenderly profile."""
+
+import requests
+
+from iwa.core.settings import settings
+
+
+def check_rpc_status(rpc_url):
+    """Check the status of an RPC endpoint."""
+    if not rpc_url:
+        print(" [!] No RPC URL found in secrets.env for this profile.")
+        return
+
+    print(f" Checking RPC: {rpc_url}")
+
+    headers = {"Content-Type": "application/json"}
+    # Include access key if present
+    if settings.tenderly_access_key:
+        headers["X-Access-Key"] = settings.tenderly_access_key.get_secret_value()
+
+    payload = {"jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": 1}
+
+    try:
+        response = requests.post(rpc_url, json=payload, headers=headers, timeout=5)
+
+        # Check for HTTP errors (like 403)
+        if response.status_code != 200:
+            print(f" [X] HTTP ERROR: {response.status_code}")
+            try:
+                err = response.json()
+                if "error" in err:
+                    print(f"     Details: {err['error']}")
+            except Exception:
+                print(f"     Response text: {response.text}")
+
+            if response.status_code == 403:
+                print("     => LIKELY QUOTA EXCEEDED (Rate Limit).")
+            return
+
+        # Check for JSON-RPC errors (like -32004)
+        data = response.json()
+        if "error" in data:
+            code = data["error"].get("code")
+            msg = data["error"].get("message")
+            print(f" [X] JSON-RPC ERROR: {code} - {msg}")
+            if code == -32004:
+                print("     => QUOTA LIMIT REACHED.")
+        else:
+            block = int(data["result"], 16)
+            print(f" [OK] API Operational. Block: {block}")
+
+    except Exception as e:
+        print(f" [!] Exception checking RPC: {e}")
+
+
+def main():
+    """Check and display the active Tenderly profile status."""
+    print(f"Active Tenderly Profile: {settings.tenderly_profile}")
+
+    # Check Gnosis RPC as primary indicator
+    rpc = settings.gnosis_rpc.get_secret_value() if settings.gnosis_rpc else None
+    check_rpc_status(rpc)
+
+
+if __name__ == "__main__":
+    main()

iwa/tools/release.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""Release helper script.
+
+Usage: python release.py <version>
+"""
+import argparse
+import subprocess  # nosec: B404
+import sys
+from typing import NoReturn
+
+
+def run(cmd: str, check: bool = True, capture: bool = False) -> str:
+    """Run a shell command."""
+    try:
+        result = subprocess.run(
+            cmd,
+            shell=True,  # nosec: B602
+            check=check,
+            text=True,
+            stdout=subprocess.PIPE if capture else None,
+            stderr=subprocess.PIPE if capture else None
+        )
+        return result.stdout.strip() if capture else ""
+    except subprocess.CalledProcessError as e:
+        if capture:
+            print(f"Error output: {e.stderr}")
+        sys.exit(e.returncode)
+
+def error(msg: str) -> NoReturn:
+    """Print error and exit."""
+    print(f"❌ Error: {msg}")
+    sys.exit(1)
+
+def info(msg: str) -> None:
+    """Print info message."""
+    print(f"🚀 {msg}")
+
+def confirm(question: str) -> bool:
+    """Ask for user confirmation."""
+    while True:
+        try:
+            choice = input(f"{question} [y/N] ").lower()
+            if not choice or choice == 'n':
+                return False
+            if choice == 'y':
+                return True
+        except EOFError:
+            return False
+
+def main() -> None:
+    """Execute the release process."""
+    parser = argparse.ArgumentParser(description="Create a new release")
+    parser.add_argument("version", help="Version tag (e.g., 0.1.0)")
+    args = parser.parse_args()
+
+    version = args.version
+    if version.startswith("v"):
+        version = version[1:]
+    tag = f"v{version}"
+
+    # 1. Check git status
+    print("Checking git status...")
+    status = run("git status --porcelain", capture=True)
+    if status:
+        error("Working directory is not clean. Commit changes first.")
+
+    try:
+        # User requested SSH agent usage. If origin is HTTPS, we try to use SSH for the check explicitly.
+        # This bypasses the HTTPS auth prompt if the user has SSH keys configured.
+        origin_url = run("git remote get-url origin", capture=True)
+        check_url = origin_url
+        if origin_url.startswith("https://github.com/"):
+            # Convert https://github.com/user/repo.git -> git@github.com:user/repo.git
+            ssh_url = origin_url.replace("https://github.com/", "git@github.com:")
+            check_url = ssh_url
+            print(f"checking remote tags via SSH ({ssh_url})...")
+
+        # Use ls-remote on the specific URL (SSH) to check tags without prompting for HTTPS creds
+        exists_remotely = run(f"git ls-remote --tags {check_url} {tag}", check=False, capture=True)
+
+    except Exception:
+        # fetch failed (likely auth), assume we can proceed to push (which might prompt or work if user is right)
+        print("⚠️  Could not fetch remote info (auth needed?). Assuming tag is new remotely.")
+        exists_remotely = ""
+
+    # 3. Check if tag exists
+    exists_locally = run(f"git rev-parse {tag}", check=False, capture=True)
+
+    if exists_locally or exists_remotely:
+        print(f"⚠️  Tag {tag} already exists!")
+        if not confirm("Do you want to FORCE update it (delete and overwrite)?"):
+            error("Aborted by user.")
+
+        info(f"Force updating {tag}...")
+        run(f"git tag -f {tag}")
+        # Push to the explicit URL (likely SSH) to avoid HTTPS prompts
+        run(f"git push -f {check_url} {tag}")
+        print(f"✅ Tag {tag} force updated. GitHub Actions triggered.")
+
+    else:
+        info(f"Preparing to release {tag}...")
+        if not confirm("Are you sure? This will trigger a deployment to PyPI and DockerHub"):
+            error("Aborted by user.")
+
+        run(f"git tag {tag}")
+        # Push to the explicit URL (likely SSH) to avoid HTTPS prompts
+        run(f"git push {check_url} {tag}")
+        print(f"✅ Release {tag} triggered! Check GitHub Actions.")
+
+if __name__ == "__main__":
+    main()

iwa/tools/reset_env.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""Tool to reset the full environment.
+
+1. Resets Tenderly networks (based on active profile).
+2. Clears Olas services from config.yaml.
+3. Clears all accounts from wallet.json except 'master'.
+"""
+
+import json
+import subprocess  # nosec B404
+import sys
+
+import yaml
+
+from iwa.core.constants import CONFIG_PATH, WALLET_PATH
+from iwa.core.settings import settings
+
+
+def _reset_tenderly(profile: int) -> None:
+    """Reset Tenderly networks using just command."""
+    cmd = ["just", "reset-tenderly", str(profile)]
+    print(f"Running: {' '.join(cmd)}")
+    try:
+        subprocess.check_call(cmd)  # nosec B603
+    except subprocess.CalledProcessError as e:
+        print(f"Error running reset-tenderly: {e}")
+        sys.exit(1)
+
+
+def _clean_olas_services() -> None:
+    """Remove all Olas services from config.yaml."""
+    if not CONFIG_PATH.exists():
+        return
+
+    try:
+        with open(CONFIG_PATH, "r") as f:
+            config = yaml.safe_load(f) or {}
+
+        if "plugins" not in config or "olas" not in config["plugins"]:
+            return
+
+        if "services" not in config["plugins"]["olas"]:
+            return
+
+        services = config["plugins"]["olas"]["services"]
+        if not services:
+            print("No Olas services found in config.yaml.")
+            return
+
+        print(f"Removing {len(services)} Olas services from config.yaml...")
+        config["plugins"]["olas"]["services"] = {}
+        with open(CONFIG_PATH, "w") as f:
+            yaml.dump(config, f)
+    except Exception as e:
+        print(f"Error cleaning config.yaml: {e}")
+
+
+def _clean_wallet_accounts() -> None:
+    """Remove all accounts from wallet.json except master."""
+    if not WALLET_PATH.exists():
+        return
+
+    try:
+        with open(WALLET_PATH, "r") as f:
+            data = json.load(f)
+
+        accounts = data.get("accounts", {})
+
+        # Find master account
+        master_addr = None
+        master_acct = None
+        for addr, acct in accounts.items():
+            if acct.get("tag") == "master":
+                master_addr = addr
+                master_acct = acct
+                break
+
+        if not master_addr:
+            print(
+                "Warning: Master account not found in wallet.json! Skipping cleanup to avoid data loss."
+            )
+            return
+
+        if len(accounts) <= 1:
+            print("Only master account exists in wallet.json.")
+            return
+
+        print(
+            f"Preserving master account ({master_addr}), removing {len(accounts) - 1} other accounts..."
+        )
+        data["accounts"] = {master_addr: master_acct}
+        with open(WALLET_PATH, "w") as f:
+            json.dump(data, f, indent=4)
+    except Exception as e:
+        print(f"Error cleaning wallet.json: {e}")
+
+
+def main():
+    """Reset the environment by clearing networks, services, and accounts."""
+    profile = settings.tenderly_profile
+    print(f"Detected Tenderly profile: {profile}")
+
+    _reset_tenderly(profile)
+    _clean_olas_services()
+    _clean_wallet_accounts()
+
+    print("Environment reset complete.")
+
+
+if __name__ == "__main__":
+    main()

iwa/tools/reset_tenderly.py

@@ -0,0 +1,362 @@
+"""Recreates Tenderly networks and funds wallets as per configuration."""
+
+import argparse
+import json
+import os
+import random
+import re
+import string
+import sys
+from typing import List, Optional, Tuple
+
+import requests
+from web3 import Web3
+
+from iwa.core.constants import SECRETS_PATH, get_tenderly_config_path
+from iwa.core.keys import KeyStorage
+from iwa.core.models import TenderlyConfig
+from iwa.core.settings import settings
+
+
+def get_tenderly_credentials() -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    """Get Tenderly credentials from settings (based on current profile)."""
+    return (
+        settings.tenderly_account_slug.get_secret_value()
+        if settings.tenderly_account_slug
+        else None,
+        settings.tenderly_project_slug.get_secret_value()
+        if settings.tenderly_project_slug
+        else None,
+        settings.tenderly_access_key.get_secret_value() if settings.tenderly_access_key else None,
+    )
+
+
+def _generate_default_config() -> TenderlyConfig:
+    """Generate a default TenderlyConfig from SupportedChains."""
+    from iwa.core.chain import SupportedChains
+    from iwa.core.models import FundRequirements, TokenAmount, VirtualNet
+
+    vnets = {}
+    chains = SupportedChains()
+
+    for chain_name, chain in [
+        ("gnosis", chains.gnosis),
+        ("ethereum", chains.ethereum),
+        ("base", chains.base),
+    ]:
+        # Get OLAS token address for this chain
+        olas_address = chain.tokens.get("OLAS")
+
+        tokens = []
+        if olas_address:
+            tokens.append(
+                TokenAmount(
+                    address=str(olas_address),
+                    symbol="OLAS",
+                    amount_eth=settings.tenderly_olas_funds,
+                )
+            )
+
+        vnets[chain_name] = VirtualNet(
+            chain_id=chain.chain_id,
+            funds_requirements={
+                "all": FundRequirements(
+                    native_eth=settings.tenderly_native_funds,
+                    tokens=tokens,
+                )
+            },
+        )
+
+    return TenderlyConfig(vnets=vnets)
+
+
+def _delete_vnet(
+    tenderly_access_key: str, account_slug: str, project_slug: str, vnet_id: str
+) -> None:
+    url = f"https://api.tenderly.co/api/v1/account/{account_slug}/project/{project_slug}/vnets/{vnet_id}"
+    requests.delete(
+        url=url,
+        timeout=300,
+        headers={"Accept": "application/json", "X-Access-Key": tenderly_access_key},
+    )
+    print(f"Deleted vnet {vnet_id}")
+
+
+def _create_vnet(
+    tenderly_access_key: str,
+    account_slug: str,
+    project_slug: str,
+    network_id: int,
+    chain_id: int,
+    vnet_slug: str,
+    vnet_display_name: str,
+    block_number: Optional[str] = "latest",
+) -> Tuple[str | None, str | None, str | None]:
+    # Define the payload for the fork creation
+    payload = {
+        "slug": vnet_slug,
+        "display_name": vnet_display_name,
+        "fork_config": {"network_id": network_id, "block_number": str(block_number)},
+        "virtual_network_config": {"chain_config": {"chain_id": chain_id}},
+        "sync_state_config": {"enabled": False},
+        "explorer_page_config": {
+            "enabled": False,
+            "verification_visibility": "bytecode",
+        },
+    }
+
+    url = f"https://api.tenderly.co/api/v1/account/{account_slug}/project/{project_slug}/vnets"
+    response = requests.post(
+        url=url,
+        timeout=300,
+        headers={
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "X-Access-Key": tenderly_access_key,
+        },
+        data=json.dumps(payload),
+    )
+
+    json_response = response.json()
+    vnet_id = json_response.get("id")
+    admin_rpc = next(
+        (rpc["url"] for rpc in json_response.get("rpcs", []) if rpc["name"] == "Admin RPC"),
+        None,
+    )
+    public_rpc = next(
+        (rpc["url"] for rpc in json_response.get("rpcs", []) if rpc["name"] == "Public RPC"),
+        None,
+    )
+    print(f"Created vnet of chain_id={network_id} at block number {block_number}")
+    return vnet_id, admin_rpc, public_rpc
+
+
+def _generate_vnet_slug(preffix: str = "vnet", length: int = 4):
+    characters = string.ascii_lowercase
+    return (
+        preffix + "-" + "".join(random.choice(characters) for _ in range(length))  # nosec
+    )
+
+
+def update_rpc_variables(tenderly_config: TenderlyConfig) -> None:
+    """Updates several files"""
+    with open(SECRETS_PATH, "r", encoding="utf-8") as file:
+        content = file.read()
+
+    for chain_name, vnet in tenderly_config.vnets.items():
+        pattern = rf"{chain_name.lower()}_test_rpc=(\S+)"
+
+        if re.search(pattern, content, re.MULTILINE):
+            content = re.sub(
+                pattern,
+                f"{chain_name.lower()}_test_rpc={vnet.public_rpc}",
+                content,
+                flags=re.MULTILINE,
+            )
+        else:
+            if content and not content.endswith("\n"):
+                content += "\n"
+            content += f"{chain_name.lower()}_test_rpc={vnet.public_rpc}\n"
+
+    with open(SECRETS_PATH, "w", encoding="utf-8") as file:
+        file.write(content)
+
+    print("Updated RPCs in secrets.env")
+
+
+def _fund_wallet(  # nosec
+    admin_rpc: str,
+    wallet_addresses: List[str],
+    amount_eth: float,
+    native_or_token_address: str = "native",
+) -> None:
+    if native_or_token_address == "native":  # nosec
+        json_data = {
+            "jsonrpc": "2.0",
+            "method": "tenderly_setBalance",
+            "params": [
+                wallet_addresses,
+                hex(Web3.to_wei(amount_eth, "ether")),  # to wei
+            ],
+            "id": "1234",
+        }
+    else:
+        json_data = {
+            "jsonrpc": "2.0",
+            "method": "tenderly_setErc20Balance",
+            "params": [
+                native_or_token_address,
+                wallet_addresses,
+                hex(Web3.to_wei(amount_eth, "ether")),  # to wei
+            ],
+            "id": "1234",
+        }
+
+    response = requests.post(
+        url=admin_rpc,
+        timeout=300,
+        headers={"Content-Type": "application/json"},
+        json=json_data,
+    )
+    if response.status_code != 200:
+        print(response.status_code)
+        try:
+            print(response.json())
+        except requests.exceptions.JSONDecodeError:  # type: ignore
+            pass
+
+
+def _process_vnet(
+    vnet_name: str,
+    vnet,
+    tenderly_access_key: str,
+    account_slug: str,
+    project_slug: str,
+    tenderly_config,
+) -> bool:
+    """Process a single vnet: delete old, create new, capture block."""
+    # Delete existing vnet
+    if vnet.vnet_id:
+        _delete_vnet(
+            tenderly_access_key=tenderly_access_key,
+            account_slug=account_slug,
+            project_slug=project_slug,
+            vnet_id=vnet.vnet_id,
+        )
+
+    # Create new network
+    vnet_slug = _generate_vnet_slug(preffix=vnet_name.lower())
+    vnet_id, admin_rpc, public_rpc = _create_vnet(
+        tenderly_access_key=tenderly_access_key,
+        account_slug=account_slug,
+        project_slug=project_slug,
+        network_id=vnet.chain_id,
+        chain_id=vnet.chain_id,
+        vnet_slug=vnet_slug,
+        vnet_display_name=vnet_slug,
+    )
+
+    if not vnet_id or not admin_rpc or not public_rpc:
+        print(f"Failed to create valid vnet for {vnet_name}")
+        return False
+
+    vnet.vnet_id = vnet_id
+    vnet.admin_rpc = admin_rpc
+    vnet.public_rpc = public_rpc
+    vnet.vnet_slug = vnet_slug
+
+    # Capture initial block
+    try:
+        w3 = Web3(Web3.HTTPProvider(public_rpc))
+        start_block = w3.eth.block_number
+        vnet.initial_block = start_block
+        print(f"Captured initial block for {vnet_name}: {start_block}")
+    except Exception as e:
+        print(f"Failed to capture initial block: {e}")
+        vnet.initial_block = 0
+
+    tenderly_config.save()
+    update_rpc_variables(tenderly_config)
+    return True
+
+
+def _fund_vnet_accounts(vnet, keys) -> None:
+    """Fund all accounts for a vnet based on requirements."""
+    for account_tags, requirement in vnet.funds_requirements.items():
+        tags = account_tags.split(",")
+        if account_tags != "all":
+            addresses = []
+            for tag in tags:
+                if acc := keys.get_account(tag):
+                    addresses.append(acc.address)
+        else:
+            addresses = list(keys.accounts.keys())
+
+        if not addresses:
+            continue
+
+        if requirement.native_eth > 0:
+            _fund_wallet(
+                admin_rpc=vnet.admin_rpc,
+                wallet_addresses=addresses,
+                amount_eth=requirement.native_eth,
+                native_or_token_address="native",
+            )
+            print(f"Funded {tags} with {requirement.native_eth} native")
+
+        for token in requirement.tokens:
+            _fund_wallet(
+                admin_rpc=vnet.admin_rpc,
+                wallet_addresses=addresses,
+                amount_eth=token.amount_eth,
+                native_or_token_address=str(token.address),
+            )
+            print(f"Funded {tags} with {token.amount_eth} {token.symbol}")
+
+
+def main() -> None:
+    """Main - uses tenderly_profile from settings."""
+    profile = settings.tenderly_profile
+    print(f"Recreating Tenderly Networks (Profile {profile})")
+
+    account_slug, project_slug, tenderly_access_key = get_tenderly_credentials()
+
+    if not account_slug or not project_slug or not tenderly_access_key:
+        print(f"Missing Tenderly environment variables for profile {profile}")
+        return
+
+    config_path = get_tenderly_config_path(profile)
+
+    if not config_path.exists():
+        print(f"Generating new config file: {config_path}")
+        tenderly_config = _generate_default_config()
+        tenderly_config.save(config_path)
+
+    tenderly_config = TenderlyConfig.load(config_path)
+
+    for vnet_name, vnet in tenderly_config.vnets.items():
+        if not _process_vnet(
+            vnet_name, vnet, tenderly_access_key, account_slug, project_slug, tenderly_config
+        ):
+            continue
+
+        # Fund wallets
+        keys = KeyStorage()
+        from iwa.core.services import AccountService, SafeService
+
+        account_service = AccountService(keys)
+        safe_service = SafeService(keys, account_service)
+
+        _fund_vnet_accounts(vnet, keys)
+
+        # Redeploy safes for Gnosis
+        if vnet_name == "Gnosis":
+            safe_service.redeploy_safes()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    parser = argparse.ArgumentParser(description="Reset Tenderly networks")
+    parser.add_argument(
+        "--profile",
+        "-p",
+        type=int,
+        default=1,
+        choices=[1, 2, 3],
+        help="Tenderly profile to use (1 or 2)",
+    )
+    args = parser.parse_args()
+
+    # Set profile env var
+    os.environ["TENDERLY_PROFILE"] = str(args.profile)
+
+    # Reset the singleton to reload with new env
+    from iwa.core.settings import Settings
+
+    Settings._instance = None  # type: ignore
+
+    # Reimport settings to get fresh instance
+    if "iwa.core.settings" in sys.modules:
+        del sys.modules["iwa.core.settings"]
+    from iwa.core.settings import settings  # noqa: F401
+
+    main()