brawny 0.1.13__py3-none-any.whl → 0.1.22__py3-none-any.whl

brawny/cli/commands/contract.py

@@ -52,7 +52,7 @@ def contract_call(
     from brawny.alerts.contracts import ContractSystem
     from brawny.logging import get_logger, setup_logging
     from brawny.model.enums import LogFormat
-    from brawny._rpc import RPCManager
+    from brawny._rpc.clients import ReadClient
 
     if not config_path or not os.path.exists(config_path):
         click.echo(
@@ -74,7 +74,7 @@ def contract_call(
         config=config.redacted_dict(),
     )
 
-    rpc = RPCManager.from_config(config)
+    rpc = ReadClient.from_config(config)
     # ContractSystem uses global ABI cache at ~/.brawny/abi_cache.db
     contract_system = ContractSystem(rpc, config)
 

brawny/cli/commands/controls.py

@@ -0,0 +1,121 @@
+"""Runtime controls commands."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+
+import click
+
+
+@click.group()
+def controls() -> None:
+    """Manage runtime controls."""
+    pass
+
+
+@controls.command("list")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def controls_list(config_path: str | None) -> None:
+    """List runtime controls."""
+    from brawny.cli.helpers import get_db
+
+    db = get_db(config_path)
+    try:
+        controls_list = db.list_runtime_controls()
+        if not controls_list:
+            click.echo("No runtime controls set.")
+            return
+        click.echo()
+        for rc in controls_list:
+            status = "active" if rc.active else "inactive"
+            expires_at = rc.expires_at.isoformat() if rc.expires_at else "none"
+            click.echo(
+                f"  {rc.control}: {status}  expires_at={expires_at}  mode={rc.mode}"
+            )
+            if rc.reason:
+                click.echo(f"    reason: {rc.reason}")
+            if rc.actor:
+                click.echo(f"    actor: {rc.actor}")
+        click.echo()
+    finally:
+        db.close()
+
+
+@controls.command("activate")
+@click.argument("control")
+@click.option(
+    "--ttl-seconds",
+    type=int,
+    default=900,
+    show_default=True,
+    help="TTL in seconds (ignored if --forever)",
+)
+@click.option("--forever", is_flag=True, help="Set without expiration")
+@click.option("--reason", "reason", default=None, help="Reason for activation")
+@click.option("--actor", "actor", default="cli", help="Actor label for audit")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def controls_activate(
+    control: str,
+    ttl_seconds: int,
+    forever: bool,
+    reason: str | None,
+    actor: str,
+    config_path: str | None,
+) -> None:
+    """Activate a runtime control."""
+    from brawny.cli.helpers import get_db
+
+    expires_at = None
+    if not forever:
+        expires_at = datetime.utcnow() + timedelta(seconds=ttl_seconds)
+
+    db = get_db(config_path)
+    try:
+        db.set_runtime_control(
+            control=control,
+            active=True,
+            expires_at=expires_at,
+            reason=reason,
+            actor=actor,
+            mode="manual",
+        )
+        if expires_at:
+            click.echo(f"Control '{control}' activated until {expires_at.isoformat()}.")
+        else:
+            click.echo(f"Control '{control}' activated with no expiration.")
+    finally:
+        db.close()
+
+
+@controls.command("deactivate")
+@click.argument("control")
+@click.option("--reason", "reason", default=None, help="Reason for deactivation")
+@click.option("--actor", "actor", default="cli", help="Actor label for audit")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def controls_deactivate(
+    control: str,
+    reason: str | None,
+    actor: str,
+    config_path: str | None,
+) -> None:
+    """Deactivate a runtime control."""
+    from brawny.cli.helpers import get_db
+
+    db = get_db(config_path)
+    try:
+        db.set_runtime_control(
+            control=control,
+            active=False,
+            expires_at=None,
+            reason=reason,
+            actor=actor,
+            mode="manual",
+        )
+        click.echo(f"Control '{control}' deactivated.")
+    finally:
+        db.close()
+
+
+def register(main) -> None:
+    """Register runtime controls commands."""
+    main.add_command(controls)

brawny/cli/commands/health.py

@@ -17,7 +17,7 @@ from brawny.cli.helpers import get_db, print_json
 def health(fmt: str, config_path: str | None) -> None:
     """Health check endpoint."""
     from brawny.config import Config, get_config
-    from brawny._rpc import RPCManager
+    from brawny._rpc.clients import ReadClient
 
     try:
         if config_path:
@@ -47,7 +47,7 @@ def health(fmt: str, config_path: str | None) -> None:
         }
 
         try:
-            rpc = RPCManager.from_config(config)
+            rpc = ReadClient.from_config(config)
             rpc_health = rpc.get_health()
             result["components"]["rpc"] = {
                 "status": "ok" if rpc_health["healthy_endpoints"] > 0 else "degraded",

brawny/cli/commands/job_dev.py

@@ -48,7 +48,7 @@ def job_run(
     from brawny.logging import get_logger, setup_logging
     from brawny.model.enums import LogFormat
     from brawny.model.types import BlockInfo, JobContext, idempotency_key
-    from brawny._rpc import RPCManager
+    from brawny._rpc.clients import ReadClient
     from brawny.scripting import set_job_context
 
     if not config_path or not os.path.exists(config_path):
@@ -73,16 +73,13 @@ def job_run(
 
     db = create_database(
         config.database_url,
-        pool_size=config.database_pool_size,
-        pool_max_overflow=config.database_pool_max_overflow,
-        pool_timeout=config.database_pool_timeout_seconds,
         circuit_breaker_failures=config.db_circuit_breaker_failures,
         circuit_breaker_seconds=config.db_circuit_breaker_seconds,
     )
     db.connect()
 
     try:
-        rpc = RPCManager.from_config(config)
+        rpc = ReadClient.from_config(config)
         contract_system = ContractSystem(rpc, config)
 
         modules = list(jobs_modules)
@@ -128,11 +125,15 @@ def job_run(
                 err=True,
             )
 
+        base_fee = 0
+        if block_data:
+            base_fee = block_data.get("baseFeePerGas", 0)
         block = BlockInfo(
             chain_id=config.chain_id,
             block_number=block_number,
             block_hash=block_hash,
             timestamp=timestamp,
+            base_fee=base_fee,
         )
 
         job_config = db.get_job(job_id)

brawny/cli/commands/jobs.py

@@ -23,6 +23,8 @@ def jobs_list(config_path: str | None) -> None:
 
     suppress_logging()
 
+    from datetime import datetime
+
     from brawny.cli.helpers import discover_jobs_for_cli, get_config, get_db
     from brawny.jobs.registry import get_registry
 
@@ -52,6 +54,18 @@ def jobs_list(config_path: str | None) -> None:
             return
 
         click.echo()
+        def _parse_drain_until(value):
+            if value is None:
+                return None
+            if isinstance(value, datetime):
+                return value
+            try:
+                return datetime.fromisoformat(value)
+            except ValueError:
+                return None
+
+        now = datetime.utcnow()
+
         for job_id in sorted(code_jobs.keys()):
             job = code_jobs[job_id]
             db_job = db_jobs.get(job_id)
@@ -62,13 +76,21 @@ def jobs_list(config_path: str | None) -> None:
             # Get enabled status from DB, default to True for new jobs
             enabled = db_job.enabled if db_job else True
 
+            drain_until = _parse_drain_until(db_job.drain_until) if db_job else None
+            draining = drain_until is not None and drain_until > now
+
             # Status indicator
-            if enabled:
+            if draining:
+                status = click.style("! draining", fg="yellow")
+            elif enabled:
                 status = click.style("✓ enabled ", fg="green")
             else:
                 status = click.style("✗ disabled", fg="red")
 
-            click.echo(f"  {status}  {job_id}  {click.style(f'every {interval} blocks', dim=True)}")
+            line = f"  {status}  {job_id}  {click.style(f'every {interval} blocks', dim=True)}"
+            if draining:
+                line += click.style(f" (until {drain_until.isoformat()})", dim=True)
+            click.echo(line)
 
         click.echo()
 
@@ -206,6 +228,81 @@ def jobs_disable(job_id: str, config_path: str | None) -> None:
         db.close()
 
 
+@jobs.command("drain")
+@click.argument("job_id")
+@click.option(
+    "--ttl-seconds",
+    type=int,
+    default=3600,
+    show_default=True,
+    help="Drain duration in seconds (ignored if --until is set)",
+)
+@click.option(
+    "--until",
+    "until_iso",
+    default=None,
+    help="Drain until ISO timestamp (e.g. 2025-01-01T00:00:00)",
+)
+@click.option("--reason", "-r", default=None, help="Reason for drain")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def jobs_drain(
+    job_id: str,
+    ttl_seconds: int,
+    until_iso: str | None,
+    reason: str | None,
+    config_path: str | None,
+) -> None:
+    """Drain a job (pause new intents) until a timestamp."""
+    from datetime import datetime, timedelta
+
+    from brawny.cli.helpers import get_db
+
+    if until_iso:
+        try:
+            drain_until = datetime.fromisoformat(until_iso)
+        except ValueError:
+            click.echo("Invalid --until format, expected ISO timestamp.", err=True)
+            raise SystemExit(1)
+    else:
+        drain_until = datetime.utcnow() + timedelta(seconds=ttl_seconds)
+
+    db = get_db(config_path)
+    try:
+        updated = db.set_job_drain(
+            job_id,
+            drain_until=drain_until,
+            reason=reason,
+            actor="cli",
+            source="cli",
+        )
+        if updated:
+            click.echo(
+                f"Job '{job_id}' drained until {drain_until.isoformat()}."
+            )
+        else:
+            click.echo(f"Job '{job_id}' not found.", err=True)
+    finally:
+        db.close()
+
+
+@jobs.command("undrain")
+@click.argument("job_id")
+@click.option("--config", "config_path", default=None, help="Path to config.yaml")
+def jobs_undrain(job_id: str, config_path: str | None) -> None:
+    """Clear job drain."""
+    from brawny.cli.helpers import get_db
+
+    db = get_db(config_path)
+    try:
+        updated = db.clear_job_drain(job_id, actor="cli", source="cli")
+        if updated:
+            click.echo(f"Job '{job_id}' undrained.")
+        else:
+            click.echo(f"Job '{job_id}' not found.", err=True)
+    finally:
+        db.close()
+
+
 @jobs.command("remove")
 @click.argument("job_id")
 @click.option("--config", "config_path", default=None, help="Path to config.yaml")

brawny/cli/commands/maintenance.py

@@ -12,7 +12,7 @@ def reconcile() -> None:
     """Run nonce reconciliation."""
     from brawny.config import get_config
     from brawny.db import create_database
-    from brawny._rpc import RPCManager
+    from brawny._rpc.clients import ReadClient
     from brawny.tx.nonce import NonceManager
 
     click.echo("Running nonce reconciliation...")
@@ -20,16 +20,13 @@ def reconcile() -> None:
     config = get_config()
     db = create_database(
         config.database_url,
-        pool_size=config.database_pool_size,
-        pool_max_overflow=config.database_pool_max_overflow,
-        pool_timeout=config.database_pool_timeout_seconds,
         circuit_breaker_failures=config.db_circuit_breaker_failures,
         circuit_breaker_seconds=config.db_circuit_breaker_seconds,
     )
     db.connect()
 
     try:
-        rpc = RPCManager.from_config(config)
+        rpc = ReadClient.from_config(config)
         nonce_manager = NonceManager(db, rpc, config.chain_id)
         nonce_manager.reconcile()
         click.echo("Nonce reconciliation complete.")
@@ -124,30 +121,17 @@ def repair_claims(
     config = get_config(config_path)
     db = get_db(config_path)
     try:
-        if db.dialect == "sqlite":
-            query = """
-                SELECT i.intent_id, i.job_id, i.claimed_at
-                FROM tx_intents i
-                WHERE i.chain_id = ?
-                  AND i.status = 'claimed'
-                  AND (i.claimed_at IS NULL OR datetime(i.claimed_at) < datetime('now', ? || ' minutes'))
-                  AND NOT EXISTS (SELECT 1 FROM tx_attempts a WHERE a.intent_id = i.intent_id)
-                ORDER BY (i.claimed_at IS NOT NULL), i.claimed_at ASC
-                LIMIT ?
-            """
-            stuck = db.execute_returning(query, (config.chain_id, -older_than, limit))
-        else:
-            query = """
-                SELECT i.intent_id, i.job_id, i.claimed_at
-                FROM tx_intents i
-                WHERE i.chain_id = %s
-                  AND i.status = 'claimed'
-                  AND (i.claimed_at IS NULL OR i.claimed_at < NOW() - make_interval(mins => %s))
-                  AND NOT EXISTS (SELECT 1 FROM tx_attempts a WHERE a.intent_id = i.intent_id)
-                ORDER BY i.claimed_at ASC NULLS FIRST
-                LIMIT %s
-            """
-            stuck = db.execute_returning(query, (config.chain_id, older_than, limit))
+        query = """
+            SELECT i.intent_id, i.job_id, i.claimed_at
+            FROM tx_intents i
+            WHERE i.chain_id = ?
+              AND i.status = 'claimed'
+              AND (i.claimed_at IS NULL OR datetime(i.claimed_at) < datetime('now', ? || ' minutes'))
+              AND NOT EXISTS (SELECT 1 FROM tx_attempts a WHERE a.intent_id = i.intent_id)
+            ORDER BY (i.claimed_at IS NOT NULL), i.claimed_at ASC
+            LIMIT ?
+        """
+        stuck = db.execute_returning(query, (config.chain_id, -older_than, limit))
 
         if not stuck:
             click.echo("No stuck claims found matching criteria.")

brawny/cli/commands/migrate.py

@@ -42,6 +42,7 @@ def migrate(status: bool, config_path: str | None) -> None:
             applied = migrator.migrate()
             for m in applied:
                 click.echo(f"  Applied: {m.version} - {m.filename}")
+            verify_critical_schema(db)
             click.echo(f"\nSuccessfully applied {len(applied)} migration(s).")
     finally:
         db.close()

brawny/cli/commands/run.py

@@ -103,9 +103,16 @@ def start(
 
     # Show signers
     if daemon.keystore:
-        signers = daemon.keystore.list_keys()
-        if signers:
-            click.echo(f"  Signers: {len(signers)} ({', '.join(signers)})")
+        signers_with_aliases = daemon.keystore.list_keys_with_aliases()
+        if signers_with_aliases:
+            # Format: "alias (0x123...)" or just "0x123..." if no alias
+            formatted = []
+            for addr, alias in signers_with_aliases:
+                if alias:
+                    formatted.append(f"{alias} ({addr[:10]}...)")
+                else:
+                    formatted.append(addr[:10] + "...")
+            click.echo(f"  Signers: {len(signers_with_aliases)} ({', '.join(formatted)})")
 
     # Show startup warnings/errors
     for msg in startup_messages:

brawny/cli/commands/script.py

@@ -66,7 +66,7 @@ def run(
     from brawny.alerts.contracts import ContractSystem
     from brawny.config import Config
     from brawny.keystore import create_keystore
-    from brawny._rpc import RPCManager
+    from brawny._rpc.clients import BroadcastClient
     from brawny.accounts import _init_accounts
     from brawny.history import _init_history
     from brawny.chain import _init_chain
@@ -103,11 +103,15 @@ def run(
         rpc_endpoints = [local_url]
         click.echo(f"Started Anvil fork at {local_url}")
 
-    # Create RPC manager
-    rpc = RPCManager(
+    # Create broadcast client
+    from brawny._rpc.retry_policy import broadcast_policy
+
+    rpc = BroadcastClient(
         endpoints=rpc_endpoints,
         timeout_seconds=config.rpc_timeout_seconds,
         max_retries=config.rpc_max_retries,
+        retry_backoff_base=config.rpc_retry_backoff_base,
+        retry_policy=broadcast_policy(config),
     )
     _set_fallback_rpc(rpc)
 
@@ -134,6 +138,7 @@ def run(
         block_number=block_data["number"],
         block_hash=block_data["hash"],
         timestamp=block_data["timestamp"],
+        base_fee=block_data.get("baseFeePerGas", 0),
     )
     ctx = JobContext(
         block=block,