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

brawny/api.py

@@ -317,7 +317,7 @@ kv = _KVProxy()
 
 
 def _get_rpc_from_context():
-    """Get RPC manager from job context or alert context."""
+    """Get RPC client from job context or alert context."""
     from brawny._context import _job_ctx, get_alert_context
 
     # Try job context first
@@ -337,10 +337,10 @@ def _get_rpc_from_context():
 
 
 class _RPCProxy:
-    """Proxy object for accessing the RPC manager.
+    """Proxy object for accessing the RPC client.
 
     Works in both job hooks (check/build_intent) and alert hooks.
-    Provides access to all RPCManager methods with failover and health tracking.
+    Provides access to ReadClient/BroadcastClient methods with retries.
 
     Usage:
         from brawny import rpc
@@ -349,12 +349,12 @@ class _RPCProxy:
             bal = rpc.get_balance(self.operator_address)
             gas = rpc.get_gas_price()
 
-        def alert_failed(self, ctx):
+        def on_failure(self, ctx):
             bal = rpc.get_balance(self.operator_address) / 1e18
     """
 
     def __getattr__(self, name: str):
-        """Delegate attribute access to the underlying RPCManager."""
+        """Delegate attribute access to the underlying RPC client."""
         return getattr(_get_rpc_from_context(), name)
 
 
@@ -362,6 +362,34 @@ class _RPCProxy:
 rpc = _RPCProxy()
 
 
+def _get_http_from_context():
+    """Get approved HTTP client from job or alert context."""
+    from brawny._context import _job_ctx, get_alert_context
+
+    job_ctx = _job_ctx.get()
+    if job_ctx is not None:
+        return job_ctx.http
+
+    alert_ctx = get_alert_context()
+    if alert_ctx is not None and getattr(alert_ctx, "http", None) is not None:
+        return alert_ctx.http
+
+    raise LookupError(
+        "No active context. Must be called from within a job hook "
+        "(check/build_intent) or alert hook (alert_*)."
+    )
+
+
+class _HTTPProxy:
+    """Proxy object for accessing approved HTTP client."""
+
+    def __getattr__(self, name: str):
+        return getattr(_get_http_from_context(), name)
+
+
+http = _HTTPProxy()
+
+
 # Thread-safe keystore address resolver - set once at startup
 import threading
 
@@ -419,7 +447,7 @@ def get_address_from_alias(alias: str) -> str:
     Usage:
         from brawny import get_address_from_alias
 
-        def alert_failed(self, ctx):
+        def on_failure(self, ctx):
             addr = get_address_from_alias("yearn-worker")
             bal = rpc.get_balance(addr) / 1e18
     """
@@ -442,8 +470,8 @@ def shorten(hex_string: str, prefix: int = 6, suffix: int = 4) -> str:
     Example:
         from brawny import shorten
 
-        def alert_confirmed(self, ctx):
-            return f"Tx: {shorten(ctx.receipt.transactionHash.hex())}"
+        def on_success(self, ctx):
+            ctx.alert(f"Tx: {shorten(ctx.receipt.transaction_hash)}")
     """
     from brawny.alerts.base import shorten as _shorten
 
@@ -471,8 +499,8 @@ def explorer_link(
     Example:
         from brawny import explorer_link
 
-        def alert_confirmed(self, ctx):
-            return f"Done!\\n{explorer_link(ctx.receipt.transactionHash.hex())}"
+        def on_success(self, ctx):
+            ctx.alert(f"Done!\\n{explorer_link(ctx.receipt.transaction_hash)}")
     """
     from brawny._context import get_alert_context
     from brawny.alerts.base import explorer_link as _explorer_link
@@ -578,7 +606,7 @@ def Wei(value: str | int) -> int:
 class _Web3Proxy:
     """Proxy for context-aware web3 access.
 
-    Provides full web3-py API while using RPCManager's health-tracked endpoints.
+    Provides full web3-py API while using the current RPC client's endpoints.
     Works in job hooks (check/build_intent) and alert hooks.
 
     Usage:

brawny/assets/AGENTS.md

@@ -0,0 +1,325 @@
+# Agent Guide: Build a Compliant brawny Job
+
+This file is meant for user agents that generate new job files. It is a fast, practical spec.
+
+## Golden Rules
+- Avoid over-engineering.
+- Aim for simplicity and elegance.
+
+## Job File Checklist (Minimal)
+- Location: `jobs/<job_name>.py`
+- Import `Job` and `job`.
+- Add `@job` decorator (omit it to hide a WIP job from discovery/validation).
+- Implement `check()` (sync or async).
+- If it sends a transaction, implement `build_intent()` (sync).
+
+## Required vs Optional Hooks
+
+### Required
+- `check(self) -> Trigger | None` OR `check(self, ctx) -> Trigger | None`
+  - Must return `trigger(...)` or `None`.
+  - **Implicit style** `def check(self):` - use API helpers (`block`, `kv`, `Contract`, `ctx()`).
+  - **Explicit style** `def check(self, ctx):` - ctx passed directly (param MUST be named 'ctx').
+  - Can be async: `async def check(self)` or `async def check(self, ctx)`.
+
+### Required only for tx jobs
+- `build_intent(self, trigger) -> TxIntentSpec`
+  - Build calldata and return `intent(...)`.
+  - Only called if `trigger.tx_required` is True.
+
+### Optional simulation hook
+- `validate_simulation(self, output) -> bool`
+  - Return False to fail the intent after a successful simulation.
+
+### Optional lifecycle hooks (for alerts and custom logic)
+- `on_trigger(self, ctx: TriggerContext)` - Called when job triggers, BEFORE build_intent().
+- `on_success(self, ctx: SuccessContext)` - Called after TX confirms.
+- `on_failure(self, ctx: FailureContext)` - Called on failure (ctx.intent may be None pre-intent).
+
+All hooks have `ctx.alert(message)` for sending alerts to job destinations.
+
+## Job Class Attributes
+
+### Required (auto-derived if not set and @job is used)
+- `job_id: str` - Stable identifier (must not change).
+- `name: str` - Human-readable name for logs/alerts.
+
+### Optional scheduling
+- `check_interval_blocks: int = 1` - Min blocks between check() calls.
+- `check_timeout_seconds: int = 30` - Timeout for check().
+- `build_timeout_seconds: int = 10` - Timeout for build_intent().
+- `max_in_flight_intents: int | None = None` - Cap on active intents.
+
+### Optional gas overrides (all values in wei)
+- `max_fee: int | None = None` - Max fee cap for gating/txs (None = no gating).
+- `priority_fee: int | None = None` - Tip override for this job.
+
+### Optional simulation
+- `disable_simulation: bool = False` - Skip pre-broadcast simulation.
+- `rpc: str | None = None` - Override RPC for simulation.
+
+### Broadcast routing (via @job decorator)
+Configure broadcast routing using the `@job` decorator:
+```python
+@job(job_id="arb_exec", rpc_group="flashbots", signer="hot1")
+class ArbitrageExecutor(Job):
+    ...
+```
+- `job_id` - Optional override (defaults to snake_case of class name).
+- `rpc_group` - Name of RPC group for reads and broadcasts.
+- `broadcast_group` - Name of RPC group for broadcasts (default: uses rpc_default_group).
+- `read_group` - Name of RPC group for read operations (default: uses rpc_default_group).
+- `signer` - Name of signer alias (required for tx jobs).
+
+Define RPC groups in config:
+```yaml
+rpc_groups:
+  primary:
+    endpoints:
+      - https://eth.llamarpc.com
+  private:
+    endpoints:
+      - https://rpc.flashbots.net
+      - https://relay.flashbots.net
+rpc_default_group: primary
+```
+
+### Alert routing
+- `@job(alert_to="ops")` - Route alerts to named chat defined in config.
+- `@job(alert_to=["ops", "dev"])` - Route to multiple chats.
+- Names must be defined in `telegram.chats` config section.
+- If not specified, uses `telegram.default` from config.
+
+## Core API (What to Use)
+
+### Contract access (brownie-style)
+```python
+from brawny import Contract
+vault = Contract(self.vault_address)  # By address
+decimals = vault.decimals()            # View call
+data = vault.harvest.encode_input()    # Get calldata
+```
+
+### JSON interfaces (brownie-style)
+Place ABI JSON files in `./interfaces`, then:
+```python
+from brawny import interface
+token = interface.IERC20("0x1234...")
+balance = token.balanceOf("0xabc...")
+```
+
+### Job hook helpers (implicit context)
+```python
+from brawny import trigger, intent, block, gas_ok
+return trigger(reason="...", data={...}, idempotency_parts=[block.number])
+return intent(signer_address="worker", to_address=addr, data=calldata)
+```
+
+### Event access in lifecycle hooks
+```python
+def on_success(self, ctx: SuccessContext):
+    if ctx.events:
+        deposit = ctx.events[0]         # First decoded event
+        amount = deposit["amount"]      # Field access
+        ctx.alert(f"Deposited {amount}")
+```
+
+### Other context access
+- `ctx()` - Get full CheckContext/BuildContext when using implicit style.
+- `block.number`, `block.timestamp` - Current block info.
+- `rpc.*` - RPC manager proxy (e.g., `rpc.get_gas_price()`).
+- `ctx.http` - Approved HTTP client for external calls.
+- `gas_ok()` - Check if current gas is below job's max_fee (async).
+- `gas_quote()` - Get current base_fee (async).
+- `kv.get(key, default=None)`, `kv.set(key, value)` - Persistent KV store (import from brawny).
+
+### Network access
+- External HTTP calls must use `ctx.http` (ApprovedHttpClient).
+- Direct network calls via `requests`, `urllib`, or raw `httpx` are blocked by network_guard.
+
+### Accounts
+- Use `intent(signer_address=...)` with a signer alias or address.
+- If you set `@job(signer="alias")`, use `self.signer` (alias) or `self.signer_address` (resolved address).
+- The signer alias must exist in the accounts directory (`~/.brawny/accounts`).
+
+## Example: Transaction Job
+
+```python
+from brawny import Job, job, Contract, trigger, intent, block
+
+@job(signer="worker")
+class MyKeeperJob(Job):
+    job_id = "my_keeper"
+    name = "My Keeper"
+    check_interval_blocks = 1
+    keeper_address = "0x..."
+
+    def check(self, ctx):
+        keeper = Contract(self.keeper_address)
+        if keeper.canWork():
+            return trigger(
+                reason="Keeper can work",
+                idempotency_parts=[block.number],
+            )
+        return None
+
+    def build_intent(self, trig):
+        keeper = Contract(self.keeper_address)
+        return intent(
+            signer_address=self.signer,
+            to_address=self.keeper_address,
+            data=keeper.work.encode_input(),
+        )
+```
+
+## Example: Job with Custom Broadcast and Alerts
+
+```python
+from brawny import Job, Contract, trigger, intent, explorer_link
+from brawny.jobs.registry import job
+
+@job(rpc_group="flashbots", signer="treasury-signer", alert_to="private_ops")
+class TreasuryJob(Job):
+    """Critical treasury operations with dedicated RPC and private alerts."""
+
+    name = "Treasury Operations"
+    check_interval_blocks = 1
+    treasury_address = "0x..."
+
+    def check(self, ctx):
+        treasury = Contract(self.treasury_address)
+        if treasury.needsRebalance():
+            return trigger(reason="Treasury needs rebalancing")
+        return None
+
+    def build_intent(self, trig):
+        treasury = Contract(self.treasury_address)
+        return intent(
+            signer_address=self.signer,
+            to_address=self.treasury_address,
+            data=treasury.rebalance.encode_input(),
+        )
+
+    def on_success(self, ctx):
+        ctx.alert(f"Treasury rebalanced: {explorer_link(ctx.receipt.transactionHash)}")
+```
+
+## Example: Monitor-Only Job (Implicit Context Style)
+
+```python
+from brawny import Job, job, Contract, trigger, kv
+
+@job
+class MonitorJob(Job):
+    job_id = "monitor"
+    name = "Monitor"
+
+    def check(self):  # No ctx param - uses implicit context
+        value = Contract("0x...").value()
+        last = kv.get("last", 0)
+        if value > last:
+            kv.set("last", value)
+            return trigger(
+                reason="Value increased",
+                data={"value": value},
+                tx_required=False,
+            )
+        return None
+```
+
+## Natural-Language -> Job Translation Guide
+
+When a user says:
+- **"Check X every block"** -> `check_interval_blocks = 1`
+- **"Only run if gas below Y"** -> set `max_fee` (wei) and use `await gas_ok()` in async check()
+- **"Use signer Z"** -> `@job(signer="Z")` and use `self.signer` in `intent(...)`
+- **"Alert on success/failure"** -> implement `on_success` / `on_failure` with `ctx.alert()`
+- **"Remember last value"** -> use `kv.get/set` (import from brawny)
+- **"Use Flashbots"** -> `@job(rpc_group="flashbots")` with flashbots group in config
+- **"Send alerts to private channel"** -> `@job(alert_to="private_ops")` with chat in config
+
+## Failure Modes
+
+The `on_failure` hook provides rich context about what failed and when.
+
+### Failure Classification
+
+**FailureType** (what failed):
+- `SIMULATION_REVERTED` - TX would revert on-chain (permanent)
+- `SIMULATION_NETWORK_ERROR` - RPC error during simulation (transient)
+- `DEADLINE_EXPIRED` - Intent took too long (permanent)
+- `SIGNER_FAILED` - Keystore/signer issue
+- `NONCE_FAILED` - Couldn't reserve nonce
+- `SIGN_FAILED` - Signing error
+- `BROADCAST_FAILED` - RPC rejected transaction (transient)
+- `TX_REVERTED` - On-chain revert (permanent)
+- `NONCE_CONSUMED` - Nonce used by another transaction
+- `CHECK_EXCEPTION` - job.check() raised an exception
+- `BUILD_TX_EXCEPTION` - job.build_tx() raised an exception
+- `UNKNOWN` - Fallback for unexpected failures
+
+**FailureStage** (when it failed):
+- `PRE_BROADCAST` - Failed before reaching the chain
+- `BROADCAST` - Failed during broadcast
+- `POST_BROADCAST` - Failed after broadcast (on-chain)
+
+### FailureContext in on_failure
+
+```python
+# FailureContext fields
+ctx.intent               # TxIntent | None (None for pre-intent failures)
+ctx.attempt              # TxAttempt | None
+ctx.error                # Exception that caused failure
+ctx.failure_type         # FailureType enum
+ctx.failure_stage        # FailureStage | None
+ctx.block                # BlockContext
+ctx.kv                   # KVReader (read-only)
+ctx.logger               # Bound logger
+
+# FailureContext methods
+ctx.alert(message)       # Send alert to job destinations
+```
+
+### Example: Handling Failures
+
+```python
+from brawny import Job, job
+from brawny.model.errors import FailureType
+from brawny.model.contexts import FailureContext
+
+@job
+class RobustJob(Job):
+    job_id = "robust_job"
+    name = "Robust Job"
+
+    def on_failure(self, ctx: FailureContext):
+        # Suppress alerts for transient failures
+        if ctx.failure_type in (
+            FailureType.SIMULATION_NETWORK_ERROR,
+            FailureType.BROADCAST_FAILED,
+        ):
+            return  # No alert for transient failures
+
+        # Detailed message for permanent failures
+        if ctx.failure_type == FailureType.SIMULATION_REVERTED:
+            ctx.alert(f"TX would revert: {ctx.error}")
+        elif ctx.failure_type == FailureType.TX_REVERTED:
+            ctx.alert(f"TX reverted on-chain: {ctx.error}")
+        elif ctx.failure_type == FailureType.NONCE_CONSUMED:
+            ctx.alert("Nonce conflict! Check signer activity.")
+        elif ctx.failure_type == FailureType.CHECK_EXCEPTION:
+            ctx.alert(f"check() crashed: {ctx.error}")
+        elif ctx.failure_type == FailureType.BUILD_TX_EXCEPTION:
+            ctx.alert(f"build_intent() crashed: {ctx.error}")
+        else:
+            ctx.alert(f"Failed ({ctx.failure_type.value}): {ctx.error}")
+```
+
+## Required Output from Agent
+When generating a new job file, the agent must provide:
+- File path
+- Job class name
+- `job_id` and `name`
+- `check()` implementation
+- `build_intent()` if tx required
+- Any alert hooks requested

brawny/async_runtime.py

@@ -0,0 +1,48 @@
+"""Async runtime boundary helpers.
+
+Provides a single owned event loop and safe sync/async adapters.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from typing import Coroutine, TypeVar
+
+T = TypeVar("T")
+
+_loop: asyncio.AbstractEventLoop | None = None
+_loop_thread_id: int | None = None
+_lock = threading.Lock()
+
+
+def register_loop(loop: asyncio.AbstractEventLoop, loop_thread_id: int) -> None:
+    """Register the owned event loop and its thread id."""
+    global _loop, _loop_thread_id
+    with _lock:
+        _loop = loop
+        _loop_thread_id = loop_thread_id
+
+
+def clear_loop() -> None:
+    """Clear the owned event loop (shutdown)."""
+    global _loop, _loop_thread_id
+    with _lock:
+        _loop = None
+        _loop_thread_id = None
+
+
+def run_sync(coro: Coroutine[object, object, T]) -> T:
+    """Run a coroutine on the owned loop from sync code."""
+    loop = _loop
+    if loop is None:
+        raise RuntimeError("run_sync called before the async loop is registered")
+    if _loop_thread_id is not None and threading.get_ident() == _loop_thread_id:
+        raise RuntimeError("Called run_sync from the loop thread — await the coroutine instead.")
+    future = asyncio.run_coroutine_threadsafe(coro, loop)
+    return future.result()
+
+
+async def to_thread(func, /, *args, **kwargs):
+    """Run sync work in a worker thread from async code."""
+    return await asyncio.to_thread(func, *args, **kwargs)

brawny/chain.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 from typing import Any, TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from brawny._rpc.manager import RPCManager
+    from brawny._rpc.clients import ReadClient
 
 
 _chain: "Chain | None" = None
@@ -26,7 +26,7 @@ class Chain:
     Provides access to block information and chain state.
     """
 
-    def __init__(self, rpc: "RPCManager", chain_id: int) -> None:
+    def __init__(self, rpc: "ReadClient", chain_id: int) -> None:
         self._rpc = rpc
         self._chain_id = chain_id
 
@@ -55,7 +55,7 @@ class Chain:
         return f"<Chain id={self._chain_id} height={self.height}>"
 
 
-def _init_chain(rpc: "RPCManager", chain_id: int) -> None:
+def _init_chain(rpc: "ReadClient", chain_id: int) -> None:
     """Initialize global chain singleton."""
     global _chain
     _chain = Chain(rpc, chain_id)

brawny/cli/commands/__init__.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from brawny.cli.commands.abi import register as register_abi
 from brawny.cli.commands.contract import register as register_contract
+from brawny.cli.commands.controls import register as register_controls
 from brawny.cli.commands.health import register as register_health
 from brawny.cli.commands.init_project import register as register_init
 from brawny.cli.commands.intents import register as register_intents
@@ -33,6 +34,7 @@ def register_all(main) -> None:
     register_accounts(main)
     register_networks(main)
     register_signer(main)  # brawny signer force-reset, status
+    register_controls(main)
     # Console has optional dependency (prompt_toolkit) - import lazily
     try:
         from brawny.cli.commands.console import register as register_console

brawny/cli/commands/console.py

@@ -139,6 +139,32 @@ def _format_syntaxerror(exc: SyntaxError) -> str:
     return result
 
 
+def _assert_console_allowed(config) -> None:
+    """Deprecated console gate (kept for compatibility)."""
+    return None
+
+
+def _resolve_completion_base(locals_dict: dict, base: str) -> Any:
+    """Resolve completion base without executing descriptors/properties."""
+    import inspect
+
+    parts = base.split(".")
+    if not parts or not re.match(r"^[A-Za-z_]\\w*$", parts[0]):
+        raise ValueError("invalid base")
+    obj = locals_dict[parts[0]]
+    if len(parts) == 1:
+        return obj
+    if len(parts) > 2:
+        raise ValueError("unsafe depth")
+    attr = parts[1]
+    if not re.match(r"^[A-Za-z_]\\w*$", attr):
+        raise ValueError("invalid attr")
+    candidate = inspect.getattr_static(obj, attr)
+    if hasattr(candidate, "__get__"):
+        raise ValueError("unsafe attr")
+    return candidate
+
+
 class ConsoleCompleter(Completer):
     """Dropdown tab-completion for the console (mirrors Brownie)."""
 
@@ -161,8 +187,8 @@ class ConsoleCompleter(Completer):
                 base, partial = expr.rsplit(".", 1)
 
                 try:
-                    obj = eval(base, self.console.locals)  # noqa: S307
-                except Exception:
+                    obj = _resolve_completion_base(self.console.locals, base)
+                except (KeyError, AttributeError, ValueError, TypeError):
                     return
 
                 for attr in dir(obj):
@@ -171,11 +197,14 @@ class ConsoleCompleter(Completer):
                         if attr.startswith("_") and not partial.startswith("_"):
                             continue
 
-                        # Add ( for callables
+                        suffix = ""
                         try:
-                            val = getattr(obj, attr)
-                            suffix = "(" if callable(val) else ""
-                        except Exception:
+                            import inspect
+
+                            val = inspect.getattr_static(obj, attr)
+                            if callable(val) and not isinstance(val, property):
+                                suffix = "("
+                        except (AttributeError, ValueError, TypeError):
                             suffix = ""
 
                         yield Completion(attr + suffix, start_position=-len(partial))
@@ -186,7 +215,7 @@ class ConsoleCompleter(Completer):
                         if name.startswith("_") and not expr.startswith("_"):
                             continue
                         yield Completion(name, start_position=-len(expr))
-        except Exception:
+        except (AttributeError, KeyError, ValueError, TypeError):
             pass  # Fail silently - no completions
 
 
@@ -254,7 +283,7 @@ class BrawnyConsole(code.InteractiveConsole):
                 highlighted = highlight(result_str, PythonLexer(), self._formatter)
                 self.write(highlighted)
             return False
-        except Exception:
+        except (SyntaxError, ValueError, TypeError):
             pass
 
         # Not an expression - run as statement
@@ -262,7 +291,7 @@ class BrawnyConsole(code.InteractiveConsole):
         return False
 
 
-@click.command("console")
+@click.command("console", hidden=True)
 @click.option("--config", "config_path", default="./config.yaml", help="Path to config.yaml")
 @click.option("--debug", is_flag=True, help="Enable debug logging")
 def console(config_path: str, debug: bool) -> None:
@@ -279,6 +308,17 @@ def console(config_path: str, debug: bool) -> None:
     import logging
     import structlog
 
+    if not os.path.exists(config_path):
+        click.echo(f"Config file not found: {config_path}", err=True)
+        sys.exit(1)
+
+    from brawny.config import Config
+
+    config = Config.from_yaml(config_path)
+    config, _ = config.apply_env_overrides()
+
+    _assert_console_allowed(config)
+
     # Suppress all logs during startup for clean console UX
     # Must configure both stdlib logging AND structlog to silence output
     if not debug:
@@ -298,17 +338,23 @@ def console(config_path: str, debug: bool) -> None:
         from brawny.logging import setup_logging, LogFormat
         setup_logging(log_level="DEBUG", log_format=LogFormat.TEXT)
 
-    from brawny.alerts.contracts import ContractSystem
-    from brawny.config import Config
-    from brawny._rpc import RPCManager
+    from brawny.logging import get_logger
 
-    if not os.path.exists(config_path):
-        click.echo(f"Config file not found: {config_path}", err=True)
-        sys.exit(1)
+    import socket
 
-    config = Config.from_yaml(config_path)
-    config, _ = config.apply_env_overrides()
+    allow_env = os.environ.get("BRAWNY_ALLOW_CONSOLE") == "1"
+    logger = get_logger(__name__)
+    logger.warning(
+        "console.opened",
+        user=os.environ.get("USER", "unknown"),
+        hostname=socket.gethostname(),
+        allow_env=allow_env,
+        config_allow=config.debug.allow_console,
+        tty=sys.stdin.isatty(),
+    )
 
+    from brawny.alerts.contracts import ContractSystem
+    from brawny._rpc.clients import BroadcastClient
     from brawny.config.routing import resolve_default_group
 
     rpc_group = resolve_default_group(config)
@@ -319,11 +365,15 @@ def console(config_path: str, debug: bool) -> None:
         click.echo("No RPC endpoints configured", err=True)
         sys.exit(1)
 
-    # Create RPC manager with selected endpoints
-    rpc = RPCManager(
+    # Create broadcast client with selected endpoints
+    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),
     )
 
     # ContractSystem uses global ABI cache at ~/.brawny/abi_cache.db