primecli 0.9.0__tar.gz → 0.10.0__tar.gz

{primecli-0.9.0 → primecli-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.9.0
+Version: 0.10.0
 Summary: Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required.
 Author: Mnemosyne-quest contributors
 License: MIT
@@ -37,7 +37,7 @@ Requires-Dist: requests>=2.31
 [![Python](https://img.shields.io/pypi/pyversions/primecli.svg)](https://pypi.org/project/primecli/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-`primecli` installs three console commands, `deltaprime`, `degenprime`, and `arbprime`, that drive the lending and leverage protocols built by the DeltaPrimeLabs team on Avalanche C-chain, Base, and Arbitrum One respectively. All share a per-user smart-account architecture (EIP-2535 diamond) and are operated through the same CLI shape: savings pools, per-user Prime / Degen Accounts, borrow / repay / fund, swaps, debt refinancing, delayed collateral withdrawals. The Avalanche side additionally exposes GMX V2 LP (GM and GM+), TraderJoe V2 LB, sJOE staking, PRIME leverage tiers, and a leveraged-long zap macro. The Arbitrum side carries the same leverage stack adapted to GMX's home chain — 10 GM + 3 GM+ markets, GLV vaults, 11 TraderJoe LB pairs, PRIME tiers, zap (no sJOE). The Base side ships a read-only Aerodrome position inventory; write paths are deferred to v2.
+`primecli` installs four console commands. Three of them — `deltaprime`, `degenprime`, and `arbprime` — drive the lending and leverage protocols built by the DeltaPrimeLabs team on Avalanche C-chain, Base, and Arbitrum One respectively. The fourth, `bridge`, moves native or ERC-20 funds between those three chains (via the LiFi aggregator) for any wallet in the shared agent table. All share a per-user smart-account architecture (EIP-2535 diamond) and are operated through the same CLI shape: savings pools, per-user Prime / Degen Accounts, borrow / repay / fund, swaps, debt refinancing, delayed collateral withdrawals. The Avalanche side additionally exposes GMX V2 LP (GM and GM+), TraderJoe V2 LB, sJOE staking, PRIME leverage tiers, and a leveraged-long zap macro. The Arbitrum side carries the same leverage stack adapted to GMX's home chain — 10 GM + 3 GM+ markets, GLV vaults, 11 TraderJoe LB pairs, PRIME tiers, zap (no sJOE). The Base side ships a read-only Aerodrome position inventory; write paths are deferred to v2.
 
 Built for agent use:
 
@@ -47,7 +47,7 @@ Built for agent use:
 - RedStone-signed solvency math handled internally, with a regression test pinning the half-boundary `toFixed(8)` encoding.
 - ParaSwap calldata validated client-side against the on-chain executor allowlist before broadcast.
 
-**Current version:** 0.9.0 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
+**Current version:** 0.10.0 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
 
 > **Breaking change in 0.5.0:** there is no longer a default signing key. Earlier versions silently fell back to a baked-in agent when no key was configured; that fallback has been removed. With no key configured, every command now fails closed with `No signing key found...`. Set a key explicitly (see [Configuration](#configuration)).
 
@@ -171,6 +171,17 @@ Full per-command + address reference: [docs/arbprime-reference.md](docs/arbprime
 
 Note: DeltaPrime has TWO deployments on Arbitrum; `arbprime` targets the live one used by app.deltaprime.io (factory `0xFf5e…c20`, TokenManager `0x0a0D…E255`), with every address verified on-chain against the live SmartLoanDiamondBeacon. The stale artifact deployment (factory `0x97f4…E4E`) only carries ETH+USDC pools — don't use addresses from the repo's `deployments/arbitrum/*TUP.json` artifacts.
 
+### `bridge` (cross-chain, Avalanche / Base / Arbitrum)
+
+Moves native or ERC-20 funds between chains for any agent in the wallet table, via the LiFi aggregator (li.quest) — same `--as <agent>` interface as the protocol commands.
+
+```bash
+bridge --as <agent> --from <chain> --to <chain> --token <SYM> --amount <decimal> \
+       [--to-token <SYM>] [--to-address <addr>] [--slippage <pct>] [--poll] [--execute]
+```
+
+Chains: `avalanche` (43114), `base` (8453), `arbitrum` (42161). `--token` is the symbol on the source chain; `--to-token` defaults to the destination chain's native gas token (a gas top-up, e.g. `AVAX` → `ETH` when bridging to Base) and can be overridden for a same-asset bridge. Dry-run by default; `--execute` broadcasts on the source chain and prints the source tx hash, source explorer URL, and the LiFi status URL (`--poll` then waits for the cross-chain leg to settle). Safety rails: **self-bridge only** (a `--to-address` that differs from the signer is refused), and the bridge is refused if the quote's implied slippage exceeds `--slippage` (default 1.0%). Because LiFi picks the cheapest route per quote, a cross-asset bridge may land at or above the cap depending on the route — re-quote, or raise `--slippage` if the price impact is acceptable. RPCs are overridable via `BRIDGE_<CHAIN>_RPC`; `LIFI_API_KEY` is sent on quote/status calls if set.
+
 ## Configuration
 
 | Env var | Default | Purpose |

{primecli-0.9.0 → primecli-0.10.0}/README.md

@@ -6,7 +6,7 @@
 [![Python](https://img.shields.io/pypi/pyversions/primecli.svg)](https://pypi.org/project/primecli/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-`primecli` installs three console commands, `deltaprime`, `degenprime`, and `arbprime`, that drive the lending and leverage protocols built by the DeltaPrimeLabs team on Avalanche C-chain, Base, and Arbitrum One respectively. All share a per-user smart-account architecture (EIP-2535 diamond) and are operated through the same CLI shape: savings pools, per-user Prime / Degen Accounts, borrow / repay / fund, swaps, debt refinancing, delayed collateral withdrawals. The Avalanche side additionally exposes GMX V2 LP (GM and GM+), TraderJoe V2 LB, sJOE staking, PRIME leverage tiers, and a leveraged-long zap macro. The Arbitrum side carries the same leverage stack adapted to GMX's home chain — 10 GM + 3 GM+ markets, GLV vaults, 11 TraderJoe LB pairs, PRIME tiers, zap (no sJOE). The Base side ships a read-only Aerodrome position inventory; write paths are deferred to v2.
+`primecli` installs four console commands. Three of them — `deltaprime`, `degenprime`, and `arbprime` — drive the lending and leverage protocols built by the DeltaPrimeLabs team on Avalanche C-chain, Base, and Arbitrum One respectively. The fourth, `bridge`, moves native or ERC-20 funds between those three chains (via the LiFi aggregator) for any wallet in the shared agent table. All share a per-user smart-account architecture (EIP-2535 diamond) and are operated through the same CLI shape: savings pools, per-user Prime / Degen Accounts, borrow / repay / fund, swaps, debt refinancing, delayed collateral withdrawals. The Avalanche side additionally exposes GMX V2 LP (GM and GM+), TraderJoe V2 LB, sJOE staking, PRIME leverage tiers, and a leveraged-long zap macro. The Arbitrum side carries the same leverage stack adapted to GMX's home chain — 10 GM + 3 GM+ markets, GLV vaults, 11 TraderJoe LB pairs, PRIME tiers, zap (no sJOE). The Base side ships a read-only Aerodrome position inventory; write paths are deferred to v2.
 
 Built for agent use:
 
@@ -16,7 +16,7 @@ Built for agent use:
 - RedStone-signed solvency math handled internally, with a regression test pinning the half-boundary `toFixed(8)` encoding.
 - ParaSwap calldata validated client-side against the on-chain executor allowlist before broadcast.
 
-**Current version:** 0.9.0 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
+**Current version:** 0.10.0 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
 
 > **Breaking change in 0.5.0:** there is no longer a default signing key. Earlier versions silently fell back to a baked-in agent when no key was configured; that fallback has been removed. With no key configured, every command now fails closed with `No signing key found...`. Set a key explicitly (see [Configuration](#configuration)).
 
@@ -140,6 +140,17 @@ Full per-command + address reference: [docs/arbprime-reference.md](docs/arbprime
 
 Note: DeltaPrime has TWO deployments on Arbitrum; `arbprime` targets the live one used by app.deltaprime.io (factory `0xFf5e…c20`, TokenManager `0x0a0D…E255`), with every address verified on-chain against the live SmartLoanDiamondBeacon. The stale artifact deployment (factory `0x97f4…E4E`) only carries ETH+USDC pools — don't use addresses from the repo's `deployments/arbitrum/*TUP.json` artifacts.
 
+### `bridge` (cross-chain, Avalanche / Base / Arbitrum)
+
+Moves native or ERC-20 funds between chains for any agent in the wallet table, via the LiFi aggregator (li.quest) — same `--as <agent>` interface as the protocol commands.
+
+```bash
+bridge --as <agent> --from <chain> --to <chain> --token <SYM> --amount <decimal> \
+       [--to-token <SYM>] [--to-address <addr>] [--slippage <pct>] [--poll] [--execute]
+```
+
+Chains: `avalanche` (43114), `base` (8453), `arbitrum` (42161). `--token` is the symbol on the source chain; `--to-token` defaults to the destination chain's native gas token (a gas top-up, e.g. `AVAX` → `ETH` when bridging to Base) and can be overridden for a same-asset bridge. Dry-run by default; `--execute` broadcasts on the source chain and prints the source tx hash, source explorer URL, and the LiFi status URL (`--poll` then waits for the cross-chain leg to settle). Safety rails: **self-bridge only** (a `--to-address` that differs from the signer is refused), and the bridge is refused if the quote's implied slippage exceeds `--slippage` (default 1.0%). Because LiFi picks the cheapest route per quote, a cross-asset bridge may land at or above the cap depending on the route — re-quote, or raise `--slippage` if the price impact is acceptable. RPCs are overridable via `BRIDGE_<CHAIN>_RPC`; `LIFI_API_KEY` is sent on quote/status calls if set.
+
 ## Configuration
 
 | Env var | Default | Purpose |

primecli-0.10.0/primecli/_wallets.py

@@ -0,0 +1,46 @@
+"""Shared named-wallet key resolution for the primecli siblings.
+
+Single source of truth for the agent→(env_file, var) secrets map and the
+helpers that read a private key out of it. degenprime and the bridge command
+import from here so the map is defined once; deltaprime/arbprime carry their own
+historical copies (kept for now to stay surgical — see the note below).
+
+Security: never log or echo the values these helpers return. They are raw
+private keys.
+"""
+
+from pathlib import Path
+
+# Named-wallet table shared with deltaprime/arbprime/degenprime/bridge. Allows
+# selecting a signer via `--as <agent>` (or the per-tool *_AGENT env vars) rather
+# than passing a raw key through the environment.
+AGENTS = {
+    "parakletos":   ("/root/.openclaw/.env",                "PARAKLETOS_EVM_PRIVATE_KEY"),
+    "paraklaudios": ("/root/paraklaudios/.credentials.env", "PARAKLAUDIOS_EVM_PRIVATE_KEY"),
+    "core1":        ("/root/.openclaw/.env",                "BRUNO_CORE1_PRIVATE_KEY"),
+}
+
+
+def _read_env_var(path, var):
+    """Return the value of `var` from a KEY=VALUE env file, or None if absent."""
+    try:
+        for line in Path(path).read_text().splitlines():
+            s = line.strip()
+            if s.startswith(var + "="):
+                return s.split("=", 1)[1].strip().strip('"').strip("'")
+    except FileNotFoundError:
+        return None
+    return None
+
+
+def _agent_key(agent):
+    if agent not in AGENTS:
+        raise RuntimeError(
+            f"Unknown agent '{agent}'. Known agents: {', '.join(AGENTS)}. "
+            f"Or set DEGENPRIME_PRIVATE_KEY, or DEGENPRIME_KEY_FILE."
+        )
+    path, var = AGENTS[agent]
+    key = _read_env_var(path, var)
+    if not key:
+        raise RuntimeError(f"{var} not found in {path} (agent '{agent}').")
+    return key

primecli-0.10.0/primecli/bridge.py

@@ -0,0 +1,406 @@
+#!/usr/bin/env python3
+"""bridge - cross-chain bridge for the primecli wallets (Avalanche / Base / Arbitrum).
+
+Move native or ERC-20 funds between chains for any wallet primecli already knows
+(parakletos, paraklaudios, core1) via the same `--as <agent>` interface the
+protocol commands use. Routing goes through the LiFi aggregator (li.quest) — the
+same endpoint and tx shape as a same-chain swap, just with toChain != fromChain.
+
+    bridge --as <agent> --from <chain> --to <chain> --token <SYM> --amount <decimal>
+           [--to-address <addr>] [--to-token <SYM>] [--slippage <pct>] [--execute]
+
+Chains: avalanche (43114) | base (8453) | arbitrum (42161).
+
+SAFETY
+  * Dry-run by DEFAULT. Only --execute broadcasts (exactly like the protocol commands).
+  * Self-bridge only (v1): the destination is the SIGNER'S OWN address. Passing a
+    --to-address that differs from the signer is REFUSED.
+  * Destination token defaults to the destination chain's native gas token
+    (gas-top-up default, e.g. AVAX -> ETH when bridging to Base). Override with
+    --to-token if you want the same asset on the other side.
+  * Slippage cap default 1.0%. If the quote's toAmountMin implies worse than the
+    cap, the bridge is REFUSED.
+
+Routing keys (set if LiFi rate-limits you):
+  LIFI_API_KEY  -> sent as x-lifi-api-key header on quote/status calls.
+"""
+
+import argparse
+import os
+import sys
+import time
+from decimal import Decimal
+
+import requests
+from eth_account import Account
+from web3 import Web3
+from web3.middleware import ExtraDataToPOAMiddleware
+
+from primecli._wallets import AGENTS, _agent_key
+
+LIFI_QUOTE_URL = "https://li.quest/v1/quote"
+LIFI_STATUS_URL = "https://li.quest/v1/status"
+
+# Native-token sentinel LiFi expects for "the chain's gas token".
+NATIVE_SENTINEL = "0x0000000000000000000000000000000000000000"
+
+ERC20_ABI = [
+    {"constant": True, "inputs": [{"name": "_owner", "type": "address"}, {"name": "_spender", "type": "address"}], "name": "allowance", "outputs": [{"name": "", "type": "uint256"}], "type": "function"},
+    {"constant": False, "inputs": [{"name": "_spender", "type": "address"}, {"name": "_value", "type": "uint256"}], "name": "approve", "outputs": [{"name": "", "type": "bool"}], "type": "function"},
+]
+
+# Chain config — the single source of truth for this command. Mirrors the shape
+# of paraklaudios/config/wallet.json but kept inline (bridge spans all three
+# chains, where each protocol module owns just one). RPCs are overridable via
+# BRIDGE_<CHAIN>_RPC so a flaky public endpoint can be swapped without an edit.
+CHAINS = {
+    "avalanche": {
+        "chain_id": 43114,
+        "rpc": os.environ.get("BRIDGE_AVALANCHE_RPC", "https://api.avax.network/ext/bc/C/rpc"),
+        "explorer": "https://snowtrace.io",
+        "poa": True,
+        "native": "AVAX",
+        "tokens": {
+            "AVAX":  {"address": None, "decimals": 18},
+            "WAVAX": {"address": "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7", "decimals": 18},
+            "USDC":  {"address": "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E", "decimals": 6},
+            "USDT":  {"address": "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7", "decimals": 6},
+        },
+    },
+    "base": {
+        "chain_id": 8453,
+        "rpc": os.environ.get("BRIDGE_BASE_RPC", "https://mainnet.base.org"),
+        "explorer": "https://basescan.org",
+        "poa": False,
+        "native": "ETH",
+        "tokens": {
+            "ETH":   {"address": None, "decimals": 18},
+            "WETH":  {"address": "0x4200000000000000000000000000000000000006", "decimals": 18},
+            "USDC":  {"address": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", "decimals": 6},
+            "USDbC": {"address": "0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA", "decimals": 6},
+        },
+    },
+    "arbitrum": {
+        "chain_id": 42161,
+        "rpc": os.environ.get("BRIDGE_ARBITRUM_RPC", "https://arb1.arbitrum.io/rpc"),
+        "explorer": "https://arbiscan.io",
+        "poa": False,
+        "native": "ETH",
+        "tokens": {
+            "ETH":  {"address": None, "decimals": 18},
+            "WETH": {"address": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1", "decimals": 18},
+            "USDC": {"address": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", "decimals": 6},
+            "USDT": {"address": "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9", "decimals": 6},
+            "ARB":  {"address": "0x912CE59144191C1204E64559FE8253a0e49E6548", "decimals": 18},
+        },
+    },
+}
+
+
+def _hexint(v, default=0):
+    """LiFi returns ints sometimes as 0x-hex strings, sometimes as decimals.
+    Parse robustly (mirrors walletctl's tolerance)."""
+    if v is None:
+        return default
+    if isinstance(v, int):
+        return v
+    s = str(v)
+    if s.startswith("0x") or s.startswith("0X"):
+        return int(s, 16)
+    return int(s)
+
+
+def resolve_token(chain, symbol):
+    """Return {symbol, address|None, decimals, native, lifi} for a symbol on a chain."""
+    cfg = CHAINS[chain]
+    sym = symbol.upper()
+    if sym not in cfg["tokens"]:
+        known = ", ".join(cfg["tokens"])
+        raise SystemExit(
+            f"Unknown token '{symbol}' on {chain}. Known: {known}. "
+            f"(Add it to CHAINS in bridge.py if you need another.)"
+        )
+    t = cfg["tokens"][sym]
+    native = t["address"] is None
+    addr = None if native else Web3.to_checksum_address(t["address"])
+    return {
+        "symbol": sym,
+        "address": addr,
+        "decimals": t["decimals"],
+        "native": native,
+        "lifi": NATIVE_SENTINEL if native else addr,
+    }
+
+
+def w3_for(chain):
+    cfg = CHAINS[chain]
+    w3 = Web3(Web3.HTTPProvider(cfg["rpc"], request_kwargs={"timeout": 20}))
+    if cfg["poa"]:
+        w3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+    return w3
+
+
+def _lifi_headers():
+    key = os.environ.get("LIFI_API_KEY")
+    return {"x-lifi-api-key": key} if key else {}
+
+
+def lifi_quote(from_chain, to_chain, from_tok, to_tok, raw_amount, address, slippage):
+    params = {
+        "fromChain": CHAINS[from_chain]["chain_id"],
+        "toChain": CHAINS[to_chain]["chain_id"],
+        "fromToken": from_tok["lifi"],
+        "toToken": to_tok["lifi"],
+        "fromAmount": str(raw_amount),
+        "fromAddress": address,
+        "toAddress": address,  # self-bridge: destination is the signer's own EOA
+        "slippage": slippage,
+    }
+    r = requests.get(LIFI_QUOTE_URL, params=params, headers=_lifi_headers(), timeout=30)
+    if r.status_code != 200:
+        raise SystemExit(f"LiFi quote failed ({r.status_code}): {r.text[:400]}")
+    return r.json()
+
+
+def build_preview(quote, from_chain, to_chain, from_tok, to_tok, amount, slippage):
+    """Turn a LiFi quote into a structured preview dict (no I/O, unit-testable)."""
+    est = quote["estimate"]
+    to_amount = Decimal(str(est["toAmount"])) / (Decimal(10) ** to_tok["decimals"])
+    to_amount_min = Decimal(str(est["toAmountMin"])) / (Decimal(10) ** to_tok["decimals"])
+    expected = to_amount if to_amount > 0 else Decimal(1)
+    implied_slippage = float((to_amount - to_amount_min) / expected) if to_amount > 0 else 0.0
+    fee_costs = est.get("feeCosts") or []
+    gas_costs = est.get("gasCosts") or []
+    fee_usd = sum(float(f.get("amountUSD", 0) or 0) for f in fee_costs)
+    gas_usd = sum(float(g.get("amountUSD", 0) or 0) for g in gas_costs)
+    tool = quote.get("tool") or quote.get("toolDetails", {}).get("name") or est.get("tool") or "?"
+    return {
+        "from_chain": from_chain,
+        "to_chain": to_chain,
+        "from_token": from_tok["symbol"],
+        "to_token": to_tok["symbol"],
+        "amount": amount,
+        "to_amount": to_amount,
+        "to_amount_min": to_amount_min,
+        "implied_slippage": implied_slippage,
+        "slippage_cap": slippage,
+        "fee_usd": fee_usd,
+        "gas_usd": gas_usd,
+        "tool": tool,
+    }
+
+
+def print_preview(p, execute):
+    mode = "EXECUTE" if execute else "DRY-RUN"
+    print(f"=== BRIDGE ({mode}) ===")
+    print(f"  from:         {p['amount']} {p['from_token']} on {p['from_chain']}")
+    print(f"  to (est):     {p['to_amount']} {p['to_token']} on {p['to_chain']}")
+    print(f"  to (min):     {p['to_amount_min']} {p['to_token']}  "
+          f"(implied slippage {p['implied_slippage']*100:.3f}%, cap {p['slippage_cap']*100:.2f}%)")
+    print(f"  route tool:   {p['tool']}")
+    print(f"  protocol fee: ${p['fee_usd']:.4f}")
+    print(f"  source gas:   ${p['gas_usd']:.4f}")
+
+
+def enforce_slippage(preview):
+    """Refuse if the quote's implied slippage is worse than the cap."""
+    if preview["implied_slippage"] > preview["slippage_cap"] + 1e-9:
+        raise SystemExit(
+            f"REFUSED: quote implies {preview['implied_slippage']*100:.3f}% slippage, "
+            f"over the {preview['slippage_cap']*100:.2f}% cap. "
+            f"Raise --slippage only if you understand the price impact."
+        )
+
+
+def _send_tx(w3, acct, tx_req, chain_id):
+    """Sign and broadcast a LiFi transactionRequest on the source chain."""
+    tx = {
+        "chainId": chain_id,
+        "from": acct.address,
+        "to": Web3.to_checksum_address(tx_req["to"]),
+        "data": tx_req["data"],
+        "value": _hexint(tx_req.get("value", 0)),
+        "nonce": w3.eth.get_transaction_count(acct.address),
+        "gas": _hexint(tx_req["gasLimit"], 0),
+    }
+    if "maxFeePerGas" in tx_req and "maxPriorityFeePerGas" in tx_req:
+        tx["maxFeePerGas"] = _hexint(tx_req["maxFeePerGas"])
+        tx["maxPriorityFeePerGas"] = _hexint(tx_req["maxPriorityFeePerGas"])
+        tx["type"] = 2
+    elif "gasPrice" in tx_req:
+        tx["gasPrice"] = _hexint(tx_req["gasPrice"])
+    signed = acct.sign_transaction(tx)
+    return w3.eth.send_raw_transaction(signed.raw_transaction)
+
+
+def poll_status(tx_hash, from_chain, to_chain, timeout=300, interval=15):
+    """Poll LiFi /v1/status until DONE/FAILED or timeout. Best-effort."""
+    params = {
+        "txHash": tx_hash,
+        "fromChain": CHAINS[from_chain]["chain_id"],
+        "toChain": CHAINS[to_chain]["chain_id"],
+    }
+    deadline = time.time() + timeout
+    last = None
+    while time.time() < deadline:
+        try:
+            r = requests.get(LIFI_STATUS_URL, params=params, headers=_lifi_headers(), timeout=20)
+            if r.status_code == 200:
+                data = r.json()
+                status = data.get("status")
+                substatus = data.get("substatus")
+                if status != last:
+                    print(f"  status: {status}" + (f" ({substatus})" if substatus else ""))
+                    last = status
+                if status in ("DONE", "FAILED", "REFUNDED"):
+                    return data
+        except requests.RequestException:
+            pass
+        time.sleep(interval)
+    print("  status: still pending after timeout — check the LiFi status URL above.")
+    return None
+
+
+def run(args):
+    if args.from_chain == args.to_chain:
+        raise SystemExit(
+            f"--from and --to are both '{args.from_chain}'. For same-chain swaps use the "
+            f"swap command, not bridge."
+        )
+    if args.agent not in AGENTS:
+        raise SystemExit(f"Unknown agent '{args.agent}'. Known: {', '.join(AGENTS)}.")
+
+    acct = Account.from_key(_agent_key(args.agent))
+
+    # Self-bridge enforcement: destination must be the signer's own address.
+    if args.to_address is not None:
+        if Web3.to_checksum_address(args.to_address) != acct.address:
+            raise SystemExit(
+                f"REFUSED: --to-address {args.to_address} differs from the signer "
+                f"({acct.address}). v1 is self-bridge only — funds can only go to the "
+                f"signer's own EOA on the destination chain."
+            )
+
+    from_tok = resolve_token(args.from_chain, args.token)
+    to_sym = args.to_token if args.to_token else CHAINS[args.to_chain]["native"]
+    to_tok = resolve_token(args.to_chain, to_sym)
+
+    slippage = args.slippage / 100.0  # CLI is a percent; LiFi wants a fraction
+    amount = Decimal(str(args.amount))
+    raw_amount = int(amount * (Decimal(10) ** from_tok["decimals"]))
+
+    print(f"signer:       {acct.address}  (--as {args.agent})")
+    quote = lifi_quote(
+        args.from_chain, args.to_chain, from_tok, to_tok, raw_amount, acct.address, slippage
+    )
+    preview = build_preview(
+        quote, args.from_chain, args.to_chain, from_tok, to_tok, amount, slippage
+    )
+    print_preview(preview, args.execute)
+    enforce_slippage(preview)
+
+    if not args.execute:
+        print("\nDry-run only. Re-run with --execute to broadcast on the source chain.")
+        return
+
+    w3 = w3_for(args.from_chain)
+    chain_id = CHAINS[args.from_chain]["chain_id"]
+    tx_req = quote["transactionRequest"]
+    spender = Web3.to_checksum_address(tx_req["to"])
+
+    # ERC-20 source token needs an allowance to the LiFi router/diamond first.
+    if not from_tok["native"]:
+        token = w3.eth.contract(address=from_tok["address"], abi=ERC20_ABI)
+        allowance = token.functions.allowance(acct.address, spender).call()
+        if allowance < raw_amount:
+            print(f"\nApproving {from_tok['symbol']} for {spender} ...")
+            fees = w3.eth.fee_history(1, "latest")
+            base_fee = fees["baseFeePerGas"][-1]
+            priority = w3.to_wei(2, "gwei") if args.from_chain == "avalanche" else w3.to_wei(1.5, "gwei")
+            approve_tx = token.functions.approve(spender, raw_amount).build_transaction({
+                "chainId": chain_id,
+                "from": acct.address,
+                "nonce": w3.eth.get_transaction_count(acct.address),
+                "maxFeePerGas": base_fee * 2 + priority,
+                "maxPriorityFeePerGas": priority,
+                "type": 2,
+            })
+            signed = acct.sign_transaction(approve_tx)
+            ah = w3.eth.send_raw_transaction(signed.raw_transaction)
+            print(f"  approve tx: {ah.hex()}")
+            w3.eth.wait_for_transaction_receipt(ah, timeout=180)
+
+    tx_hash = _send_tx(w3, acct, tx_req, chain_id)
+    hx = tx_hash.hex()
+    if not hx.startswith("0x"):
+        hx = "0x" + hx
+    explorer = CHAINS[args.from_chain]["explorer"]
+    status_url = (
+        f"{LIFI_STATUS_URL}?txHash={hx}"
+        f"&fromChain={CHAINS[args.from_chain]['chain_id']}"
+        f"&toChain={CHAINS[args.to_chain]['chain_id']}"
+    )
+    print(f"\nBroadcast on {args.from_chain}: {hx}")
+    print(f"Source explorer: {explorer}/tx/{hx}")
+    print(f"LiFi status:     {status_url}")
+
+    if args.poll:
+        print("\nPolling LiFi for cross-chain completion ...")
+        final = poll_status(hx, args.from_chain, args.to_chain)
+        if final:
+            print(f"Final status: {final.get('status')} "
+                  f"({final.get('substatus', '')})".rstrip(" ()"))
+
+
+def build_parser():
+    p = argparse.ArgumentParser(
+        prog="bridge",
+        description="Cross-chain bridge for primecli wallets (Avalanche / Base / Arbitrum) via LiFi.",
+    )
+    p.add_argument("--as", dest="agent", required=True,
+                   help="Wallet to sign as: " + ", ".join(AGENTS))
+    p.add_argument("--from", dest="from_chain", required=True, choices=list(CHAINS),
+                   help="Source chain.")
+    p.add_argument("--to", dest="to_chain", required=True, choices=list(CHAINS),
+                   help="Destination chain.")
+    p.add_argument("--token", required=True,
+                   help="Token symbol on the SOURCE chain (e.g. AVAX, ETH, USDC).")
+    p.add_argument("--amount", required=True,
+                   help="Amount of --token to bridge (decimal).")
+    p.add_argument("--to-token", default=None,
+                   help="Token to receive on the destination chain. "
+                        "Default: the destination chain's native gas token (gas top-up).")
+    p.add_argument("--to-address", default=None,
+                   help="Destination address. Must equal the signer (self-bridge only); "
+                        "omit to default to the signer's own EOA.")
+    p.add_argument("--slippage", type=float, default=1.0,
+                   help="Max slippage percent (default 1.0). Quotes worse than this are refused.")
+    p.add_argument("--poll", action="store_true",
+                   help="After --execute, poll LiFi status until the bridge completes or times out.")
+    p.add_argument("--execute", action="store_true",
+                   help="Broadcast the bridge tx. Without this flag the command is a dry-run.")
+    # Accepted for parity with the other primecli commands; the actual suppression
+    # is handled by check_version() reading sys.argv directly.
+    p.add_argument("--no-version-check", action="store_true", help=argparse.SUPPRESS)
+    return p
+
+
+def main(argv=None):
+    try:
+        from primecli import check_version
+    except ImportError:
+        def check_version(*a, **kw):
+            pass
+    check_version()
+    args = build_parser().parse_args(argv)
+    # argparse stores --amount as a string; validate it is a positive number early.
+    try:
+        if Decimal(str(args.amount)) <= 0:
+            raise SystemExit("--amount must be positive.")
+    except (ArithmeticError, ValueError):
+        raise SystemExit(f"--amount '{args.amount}' is not a valid number.")
+    run(args)
+
+
+if __name__ == "__main__":
+    main()

{primecli-0.9.0 → primecli-0.10.0}/primecli/degenprime.py

@@ -180,43 +180,17 @@ ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"
 # read lazily so read-only commands that don't sign never need a key at all.
 _CLI_KEY = None  # set by the --key CLI flag in main()
 
-# Named-wallet table shared with deltaprime/arbprime. Allows running via
+# Named-wallet table shared with deltaprime/arbprime/bridge. Allows running via
 # DEGENPRIME_AGENT=parakletos (or the fallback DELTAPRIME_AGENT) which is
 # cleaner than passing raw keys through environment variables.
 # Agent resolution also supports --as <agent> CLI flag.
-AGENTS = {
-    "parakletos":   ("/root/.openclaw/.env",                "PARAKLETOS_EVM_PRIVATE_KEY"),
-    "paraklaudios": ("/root/paraklaudios/.credentials.env", "PARAKLAUDIOS_EVM_PRIVATE_KEY"),
-    "core1":   ("/root/.openclaw/.env",                "BRUNO_CORE1_PRIVATE_KEY"),
-}
+# The map and its readers live in primecli._wallets as the single source of
+# truth; re-exported here so existing references (degenprime.AGENTS, etc.) and
+# resolve_private_key() below keep working unchanged.
+from primecli._wallets import AGENTS, _read_env_var, _agent_key  # noqa: E402
 _SELECTED_AGENT = None        # set by the --as CLI flag in main()
 
 
-def _read_env_var(path, var):
-    """Return the value of `var` from a KEY=VALUE env file, or None if absent."""
-    try:
-        for line in Path(path).read_text().splitlines():
-            s = line.strip()
-            if s.startswith(var + "="):
-                return s.split("=", 1)[1].strip().strip('"').strip("'")
-    except FileNotFoundError:
-        return None
-    return None
-
-
-def _agent_key(agent):
-    if agent not in AGENTS:
-        raise RuntimeError(
-            f"Unknown agent '{agent}'. Known agents: {', '.join(AGENTS)}. "
-            f"Or set DEGENPRIME_PRIVATE_KEY, or DEGENPRIME_KEY_FILE."
-        )
-    path, var = AGENTS[agent]
-    key = _read_env_var(path, var)
-    if not key:
-        raise RuntimeError(f"{var} not found in {path} (agent '{agent}').")
-    return key
-
-
 # Core protocol addresses (verified on Base 2026-05-29).
 FACTORY_PROXY = "0x5A6a0e2702cF4603a098C3Df01f3F0DF56115456"  # SmartLoansFactory TUP
 # Diamond beacon. Every Degen Account is a per-user proxy that delegates here, so the
@@ -4353,8 +4327,10 @@ def _aero_rebalance_events(account: str, from_block=None, to_block="latest"):
     if from_block is None:
         # The shared emitter went live with the 2026-06-16 migration; a recent window
         # covers all post-migration history. Public Base RPCs cap getLogs at 50k blocks,
-        # so default to ~180k blocks back (≈4 days at 2s/block) and page under the cap.
-        from_block = max(0, latest - 180_000)
+        # so default to ~90k blocks back (≈50h at 2s/block, covering the 48h KO window)
+        # and page under the cap. All four event types are fetched in ONE getLogs per
+        # chunk (topic0 OR-list) below, so this stays fast enough for a per-tick call.
+        from_block = max(0, latest - 90_000)
     # Non-indexed arg types per event (indexed userContract/user/tokenId/executor live
     # in the topics, not the data blob).
     nonindexed = {
@@ -4364,47 +4340,52 @@ def _aero_rebalance_events(account: str, from_block=None, to_block="latest"):
         "RebalanceExecuted":      ["uint160", "uint160", "uint256", "uint256"],
     }
     CHUNK = 45_000  # under the public-RPC 50k-block getLogs cap
+    # Reverse map topic0 -> event name so a SINGLE getLogs (topic0 as an OR-list) returns
+    # all four event types per chunk, then is demuxed here. One scan per event type
+    # (the previous approach) meant 4x the getLogs round-trips, which timed out the
+    # per-tick range-monitor call.
+    t0_to_name = {t.lower().removeprefix("0x"): n for n, t in REBALANCE_TOPIC0.items()}
+    all_topic0 = list(REBALANCE_TOPIC0.values())
     out = []
-    for name, topic0 in REBALANCE_TOPIC0.items():
-        logs = []
-        start = from_block
-        try:
-            while start <= to_block:
-                end = min(start + CHUNK - 1, to_block)
-                logs.extend(w3.eth.get_logs({"address": emitter, "fromBlock": start,
-                                             "toBlock": end, "topics": [topic0, acct_topic]}))
-                start = end + 1
-        except Exception as e:
-            print(f"  (getLogs failed for {name}: {type(e).__name__}: {str(e)[:120]})")
-            continue
-        for lg in logs:
-            ev = {"event": name, "block": lg["blockNumber"],
-                  "logIndex": lg["logIndex"], "tx": lg["transactionHash"].hex()}
-            # topic2 is tokenId (Created/Updated/Canceled) or executor (Executed);
-            # for Executed the OLD tokenId is topic3.
-            topics = lg["topics"]
-            decoded = w3.codec.decode(nonindexed[name], bytes(lg["data"]))
-            if name == "RebalanceExecuted":
-                ev["executor"] = "0x" + topics[2].hex()[-40:]
-                ev["tokenId"] = int(topics[3].hex(), 16)
-                ev["oldRefSqrtPriceX96"] = decoded[0]
-                ev["currentSqrtPriceX96"] = decoded[1]
-                ev["newTokenId"] = decoded[2]
-                ev["timestamp"] = decoded[3]
-            else:
-                ev["tokenId"] = int(topics[3].hex(), 16) if len(topics) > 3 else None
-                if name == "RebalanceOrderCreated":
-                    ev["rangeBps"] = [decoded[0], decoded[1]]
-                    ev["triggerBps"] = [decoded[2], decoded[3]]
-                    ev["executionFeeWeth"] = decoded[4]
-                    ev["timestamp"] = decoded[5]
-                elif name == "RebalanceOrderUpdated":
-                    ev["rangeBps"] = [decoded[0], decoded[1]]
-                    ev["triggerBps"] = [decoded[2], decoded[3]]
-                    ev["timestamp"] = decoded[4]
-                elif name == "RebalanceOrderCanceled":
-                    ev["timestamp"] = decoded[0]
-            out.append(ev)
+    start = from_block
+    try:
+        while start <= to_block:
+            end = min(start + CHUNK - 1, to_block)
+            chunk_logs = w3.eth.get_logs({"address": emitter, "fromBlock": start,
+                                          "toBlock": end, "topics": [all_topic0, acct_topic]})
+            for lg in chunk_logs:
+                name = t0_to_name.get(lg["topics"][0].hex().lower().removeprefix("0x"))
+                if name is None:
+                    continue
+                ev = {"event": name, "block": lg["blockNumber"],
+                      "logIndex": lg["logIndex"], "tx": lg["transactionHash"].hex()}
+                # topic2 is executor (Executed); topic3 is the tokenId (all four events).
+                topics = lg["topics"]
+                decoded = w3.codec.decode(nonindexed[name], bytes(lg["data"]))
+                if name == "RebalanceExecuted":
+                    ev["executor"] = "0x" + topics[2].hex()[-40:]
+                    ev["tokenId"] = int(topics[3].hex(), 16)
+                    ev["oldRefSqrtPriceX96"] = decoded[0]
+                    ev["currentSqrtPriceX96"] = decoded[1]
+                    ev["newTokenId"] = decoded[2]
+                    ev["timestamp"] = decoded[3]
+                else:
+                    ev["tokenId"] = int(topics[3].hex(), 16) if len(topics) > 3 else None
+                    if name == "RebalanceOrderCreated":
+                        ev["rangeBps"] = [decoded[0], decoded[1]]
+                        ev["triggerBps"] = [decoded[2], decoded[3]]
+                        ev["executionFeeWeth"] = decoded[4]
+                        ev["timestamp"] = decoded[5]
+                    elif name == "RebalanceOrderUpdated":
+                        ev["rangeBps"] = [decoded[0], decoded[1]]
+                        ev["triggerBps"] = [decoded[2], decoded[3]]
+                        ev["timestamp"] = decoded[4]
+                    elif name == "RebalanceOrderCanceled":
+                        ev["timestamp"] = decoded[0]
+                out.append(ev)
+            start = end + 1
+    except Exception as e:
+        print(f"  (getLogs failed: {type(e).__name__}: {str(e)[:120]})")
     out.sort(key=lambda e: (e["block"], e["logIndex"]))
     return out
 

{primecli-0.9.0 → primecli-0.10.0}/primecli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.9.0
+Version: 0.10.0
 Summary: Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required.
 Author: Mnemosyne-quest contributors
 License: MIT
@@ -37,7 +37,7 @@ Requires-Dist: requests>=2.31
 [![Python](https://img.shields.io/pypi/pyversions/primecli.svg)](https://pypi.org/project/primecli/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-`primecli` installs three console commands, `deltaprime`, `degenprime`, and `arbprime`, that drive the lending and leverage protocols built by the DeltaPrimeLabs team on Avalanche C-chain, Base, and Arbitrum One respectively. All share a per-user smart-account architecture (EIP-2535 diamond) and are operated through the same CLI shape: savings pools, per-user Prime / Degen Accounts, borrow / repay / fund, swaps, debt refinancing, delayed collateral withdrawals. The Avalanche side additionally exposes GMX V2 LP (GM and GM+), TraderJoe V2 LB, sJOE staking, PRIME leverage tiers, and a leveraged-long zap macro. The Arbitrum side carries the same leverage stack adapted to GMX's home chain — 10 GM + 3 GM+ markets, GLV vaults, 11 TraderJoe LB pairs, PRIME tiers, zap (no sJOE). The Base side ships a read-only Aerodrome position inventory; write paths are deferred to v2.
+`primecli` installs four console commands. Three of them — `deltaprime`, `degenprime`, and `arbprime` — drive the lending and leverage protocols built by the DeltaPrimeLabs team on Avalanche C-chain, Base, and Arbitrum One respectively. The fourth, `bridge`, moves native or ERC-20 funds between those three chains (via the LiFi aggregator) for any wallet in the shared agent table. All share a per-user smart-account architecture (EIP-2535 diamond) and are operated through the same CLI shape: savings pools, per-user Prime / Degen Accounts, borrow / repay / fund, swaps, debt refinancing, delayed collateral withdrawals. The Avalanche side additionally exposes GMX V2 LP (GM and GM+), TraderJoe V2 LB, sJOE staking, PRIME leverage tiers, and a leveraged-long zap macro. The Arbitrum side carries the same leverage stack adapted to GMX's home chain — 10 GM + 3 GM+ markets, GLV vaults, 11 TraderJoe LB pairs, PRIME tiers, zap (no sJOE). The Base side ships a read-only Aerodrome position inventory; write paths are deferred to v2.
 
 Built for agent use:
 
@@ -47,7 +47,7 @@ Built for agent use:
 - RedStone-signed solvency math handled internally, with a regression test pinning the half-boundary `toFixed(8)` encoding.
 - ParaSwap calldata validated client-side against the on-chain executor allowlist before broadcast.
 
-**Current version:** 0.9.0 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
+**Current version:** 0.10.0 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
 
 > **Breaking change in 0.5.0:** there is no longer a default signing key. Earlier versions silently fell back to a baked-in agent when no key was configured; that fallback has been removed. With no key configured, every command now fails closed with `No signing key found...`. Set a key explicitly (see [Configuration](#configuration)).
 
@@ -171,6 +171,17 @@ Full per-command + address reference: [docs/arbprime-reference.md](docs/arbprime
 
 Note: DeltaPrime has TWO deployments on Arbitrum; `arbprime` targets the live one used by app.deltaprime.io (factory `0xFf5e…c20`, TokenManager `0x0a0D…E255`), with every address verified on-chain against the live SmartLoanDiamondBeacon. The stale artifact deployment (factory `0x97f4…E4E`) only carries ETH+USDC pools — don't use addresses from the repo's `deployments/arbitrum/*TUP.json` artifacts.
 
+### `bridge` (cross-chain, Avalanche / Base / Arbitrum)
+
+Moves native or ERC-20 funds between chains for any agent in the wallet table, via the LiFi aggregator (li.quest) — same `--as <agent>` interface as the protocol commands.
+
+```bash
+bridge --as <agent> --from <chain> --to <chain> --token <SYM> --amount <decimal> \
+       [--to-token <SYM>] [--to-address <addr>] [--slippage <pct>] [--poll] [--execute]
+```
+
+Chains: `avalanche` (43114), `base` (8453), `arbitrum` (42161). `--token` is the symbol on the source chain; `--to-token` defaults to the destination chain's native gas token (a gas top-up, e.g. `AVAX` → `ETH` when bridging to Base) and can be overridden for a same-asset bridge. Dry-run by default; `--execute` broadcasts on the source chain and prints the source tx hash, source explorer URL, and the LiFi status URL (`--poll` then waits for the cross-chain leg to settle). Safety rails: **self-bridge only** (a `--to-address` that differs from the signer is refused), and the bridge is refused if the quote's implied slippage exceeds `--slippage` (default 1.0%). Because LiFi picks the cheapest route per quote, a cross-asset bridge may land at or above the cap depending on the route — re-quote, or raise `--slippage` if the price impact is acceptable. RPCs are overridable via `BRIDGE_<CHAIN>_RPC`; `LIFI_API_KEY` is sent on quote/status calls if set.
+
 ## Configuration
 
 | Env var | Default | Purpose |

{primecli-0.9.0 → primecli-0.10.0}/primecli.egg-info/SOURCES.txt

@@ -2,7 +2,9 @@ LICENSE
 README.md
 pyproject.toml
 primecli/__init__.py
+primecli/_wallets.py
 primecli/arbprime.py
+primecli/bridge.py
 primecli/degenprime.py
 primecli/deltaprime.py
 primecli/health_monitor.py
@@ -13,6 +15,7 @@ primecli.egg-info/entry_points.txt
 primecli.egg-info/requires.txt
 primecli.egg-info/top_level.txt
 tests/test_aero_rebalance.py
+tests/test_bridge.py
 tests/test_cross_file_identity.py
 tests/test_gas_limit.py
 tests/test_gas_pricing.py

{primecli-0.9.0 → primecli-0.10.0}/primecli.egg-info/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
 arbprime = primecli.arbprime:main
+bridge = primecli.bridge:main
 degenprime = primecli.degenprime:main
 deltaprime = primecli.deltaprime:main

{primecli-0.9.0 → primecli-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "primecli"
-version = "0.9.0"
+version = "0.10.0"
 description = "Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -42,6 +42,7 @@ Documentation = "https://github.com/Mnemosyne-quest/primecli/tree/main/docs"
 deltaprime = "primecli.deltaprime:main"
 degenprime = "primecli.degenprime:main"
 arbprime = "primecli.arbprime:main"
+bridge = "primecli.bridge:main"
 
 [tool.setuptools.packages.find]
 include = ["primecli*"]

primecli-0.10.0/tests/test_bridge.py

@@ -0,0 +1,239 @@
+"""Tests for the cross-chain bridge command (primecli.bridge).
+
+Pure/offline like the rest of the suite: the one path that would hit the network
+(LiFi quote) is monkeypatched, and key resolution is monkeypatched so no real
+private key is read. Nothing here builds an RPC connection or signs a tx.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+
+import pytest
+
+from primecli import bridge
+
+
+# ── arg parsing ───────────────────────────────────────────────────────────────
+
+
+def test_parser_basic():
+    args = bridge.build_parser().parse_args(
+        ["--as", "core1", "--from", "avalanche", "--to", "base",
+         "--token", "AVAX", "--amount", "1"]
+    )
+    assert args.agent == "core1"
+    assert args.from_chain == "avalanche"
+    assert args.to_chain == "base"
+    assert args.token == "AVAX"
+    assert args.amount == "1"
+    assert args.to_token is None          # defaults to dest-native downstream
+    assert args.to_address is None
+    assert args.slippage == 1.0           # default cap
+    assert args.execute is False          # dry-run by default
+    assert args.poll is False
+
+
+def test_parser_rejects_unknown_chain():
+    with pytest.raises(SystemExit):
+        bridge.build_parser().parse_args(
+            ["--as", "core1", "--from", "ethereum", "--to", "base",
+             "--token", "ETH", "--amount", "1"]
+        )
+
+
+def test_parser_requires_agent():
+    with pytest.raises(SystemExit):
+        bridge.build_parser().parse_args(
+            ["--from", "avalanche", "--to", "base", "--token", "AVAX", "--amount", "1"]
+        )
+
+
+# ── token resolution ──────────────────────────────────────────────────────────
+
+
+def test_resolve_native_token():
+    t = bridge.resolve_token("avalanche", "avax")
+    assert t["native"] is True
+    assert t["address"] is None
+    assert t["lifi"] == bridge.NATIVE_SENTINEL
+    assert t["decimals"] == 18
+
+
+def test_resolve_erc20_token():
+    t = bridge.resolve_token("base", "usdc")
+    assert t["native"] is False
+    assert t["lifi"] == t["address"]
+    assert t["decimals"] == 6
+
+
+def test_resolve_unknown_token_refuses():
+    with pytest.raises(SystemExit):
+        bridge.resolve_token("base", "DOGE")
+
+
+# ── hex/int tolerance (LiFi returns mixed types) ──────────────────────────────
+
+
+@pytest.mark.parametrize("value,expected", [
+    (123, 123),
+    ("123", 123),
+    ("0x7b", 123),
+    ("0X7B", 123),
+    (None, 0),
+])
+def test_hexint(value, expected):
+    assert bridge._hexint(value) == expected
+
+
+# ── preview math + slippage gate ──────────────────────────────────────────────
+
+
+def _quote(to_amount, to_amount_min, tool="across", fee_usd=0.12, gas_usd=0.30):
+    """Minimal LiFi-quote shape covering the fields build_preview reads."""
+    return {
+        "tool": tool,
+        "estimate": {
+            "toAmount": str(to_amount),
+            "toAmountMin": str(to_amount_min),
+            "feeCosts": [{"amountUSD": str(fee_usd)}],
+            "gasCosts": [{"amountUSD": str(gas_usd)}],
+        },
+    }
+
+
+def test_build_preview_fields():
+    to_tok = bridge.resolve_token("base", "ETH")  # 18 decimals
+    q = _quote(to_amount=10 ** 18, to_amount_min=int(0.995 * 10 ** 18))
+    p = bridge.build_preview(q, "avalanche", "base",
+                             bridge.resolve_token("avalanche", "AVAX"), to_tok,
+                             Decimal("1"), 0.01)
+    assert p["from_chain"] == "avalanche"
+    assert p["to_chain"] == "base"
+    assert p["from_token"] == "AVAX"
+    assert p["to_token"] == "ETH"
+    assert p["to_amount"] == Decimal(1)
+    assert p["tool"] == "across"
+    assert p["fee_usd"] == pytest.approx(0.12)
+    assert p["gas_usd"] == pytest.approx(0.30)
+    # 1.0 -> 0.995 is 0.5% implied slippage
+    assert p["implied_slippage"] == pytest.approx(0.005, abs=1e-6)
+
+
+def test_enforce_slippage_passes_within_cap():
+    to_tok = bridge.resolve_token("base", "ETH")
+    q = _quote(to_amount=10 ** 18, to_amount_min=int(0.995 * 10 ** 18))
+    p = bridge.build_preview(q, "avalanche", "base",
+                             bridge.resolve_token("avalanche", "AVAX"), to_tok,
+                             Decimal("1"), 0.01)
+    bridge.enforce_slippage(p)  # 0.5% < 1% cap → no raise
+
+
+def test_enforce_slippage_refuses_over_cap():
+    to_tok = bridge.resolve_token("base", "ETH")
+    q = _quote(to_amount=10 ** 18, to_amount_min=int(0.97 * 10 ** 18))  # 3% slippage
+    p = bridge.build_preview(q, "avalanche", "base",
+                             bridge.resolve_token("avalanche", "AVAX"), to_tok,
+                             Decimal("1"), 0.01)  # 1% cap
+    with pytest.raises(SystemExit) as ei:
+        bridge.enforce_slippage(p)
+    assert "slippage" in str(ei.value).lower()
+
+
+# ── self-bridge enforcement + full dry-run (mocked quote, no network) ──────────
+
+SIGNER = "0x8282fb51649Ce5f474db3e274C47ed04C97b504B"
+
+
+@pytest.fixture
+def fake_signer(monkeypatch):
+    """Make _agent_key return a deterministic key whose address is SIGNER, so no
+    real secret is read and Account.from_key yields a known address."""
+    # Private key for the SIGNER address above is not known; instead patch
+    # Account.from_key to return a stub account with .address == SIGNER.
+    class _Acct:
+        address = SIGNER
+
+        def sign_transaction(self, tx):  # never called in dry-run
+            raise AssertionError("sign_transaction must not run in a dry-run test")
+
+    monkeypatch.setattr(bridge, "_agent_key", lambda agent: "0x" + "11" * 32)
+    monkeypatch.setattr(bridge.Account, "from_key", staticmethod(lambda key: _Acct()))
+    return _Acct()
+
+
+def test_run_refuses_foreign_to_address(fake_signer):
+    args = bridge.build_parser().parse_args(
+        ["--as", "core1", "--from", "avalanche", "--to", "base",
+         "--token", "AVAX", "--amount", "1",
+         "--to-address", "0x000000000000000000000000000000000000dEaD"]
+    )
+    with pytest.raises(SystemExit) as ei:
+        bridge.run(args)
+    assert "self-bridge" in str(ei.value).lower()
+
+
+def test_run_allows_own_to_address(fake_signer, monkeypatch):
+    # Passing the signer's own address explicitly must be accepted (and reach the quote).
+    captured = {}
+
+    def _fake_quote(from_chain, to_chain, from_tok, to_tok, raw_amount, address, slippage):
+        captured["address"] = address
+        captured["raw_amount"] = raw_amount
+        return _quote(to_amount=10 ** 18, to_amount_min=int(0.997 * 10 ** 18))
+
+    monkeypatch.setattr(bridge, "lifi_quote", _fake_quote)
+    args = bridge.build_parser().parse_args(
+        ["--as", "core1", "--from", "avalanche", "--to", "base",
+         "--token", "AVAX", "--amount", "1", "--to-address", SIGNER]
+    )
+    bridge.run(args)  # dry-run: no execute, must not raise
+    assert captured["address"] == SIGNER
+    assert captured["raw_amount"] == 10 ** 18  # 1 AVAX at 18 decimals
+
+
+def test_run_dryrun_core1_avax_to_base(fake_signer, monkeypatch, capsys):
+    """The motivating use case: core1 bridges 1 AVAX (Avalanche) -> ETH (Base),
+    dry-run. Mocked quote, asserts the preview is sane and nothing broadcasts."""
+    def _fake_quote(from_chain, to_chain, from_tok, to_tok, raw_amount, address, slippage):
+        assert from_chain == "avalanche" and to_chain == "base"
+        assert from_tok["symbol"] == "AVAX" and to_tok["symbol"] == "ETH"
+        assert to_tok["native"] is True  # default dest token = Base native gas token
+        return _quote(to_amount=int(0.0123 * 10 ** 18),
+                      to_amount_min=int(0.0122 * 10 ** 18), tool="across")
+
+    monkeypatch.setattr(bridge, "lifi_quote", _fake_quote)
+    args = bridge.build_parser().parse_args(
+        ["--as", "core1", "--from", "avalanche", "--to", "base",
+         "--token", "AVAX", "--amount", "1"]
+    )
+    bridge.run(args)
+    out = capsys.readouterr().out
+    assert "BRIDGE (DRY-RUN)" in out
+    assert "AVAX on avalanche" in out
+    assert "ETH on base" in out
+    assert "Dry-run only" in out
+    assert "Broadcast" not in out  # nothing signed/sent
+
+
+def test_run_dryrun_refuses_when_slippage_blown(fake_signer, monkeypatch):
+    def _fake_quote(*a, **k):
+        return _quote(to_amount=10 ** 18, to_amount_min=int(0.95 * 10 ** 18))  # 5%
+
+    monkeypatch.setattr(bridge, "lifi_quote", _fake_quote)
+    args = bridge.build_parser().parse_args(
+        ["--as", "core1", "--from", "avalanche", "--to", "base",
+         "--token", "AVAX", "--amount", "1"]  # default 1% cap
+    )
+    with pytest.raises(SystemExit):
+        bridge.run(args)
+
+
+def test_run_refuses_same_chain(fake_signer):
+    args = bridge.build_parser().parse_args(
+        ["--as", "core1", "--from", "base", "--to", "base",
+         "--token", "ETH", "--amount", "1"]
+    )
+    with pytest.raises(SystemExit) as ei:
+        bridge.run(args)
+    assert "same-chain" in str(ei.value).lower() or "swap" in str(ei.value).lower()