Cross-Chain Bridging for AI Agents: Moving Value Across 8 Chains

"""
Cross-Chain Rebalancing Agent using Purple Flea Wallet API
Automatically rebalances holdings across ETH, SOL, MATIC, BNB, AVAX
"""

import asyncio
import logging
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Tuple
from decimal import Decimal
import aiohttp
import time

logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
log = logging.getLogger('rebalancer')

# ─── Configuration ─────────────────────────────────────────────────────────

PURPLEFLEA_API = "https://purpleflea.com/wallet-api"
API_KEY = "your_api_key_here"

# Target allocation as fraction of total portfolio
TARGET_ALLOCATION: Dict[str, float] = {
    "ETH":   0.40,
    "SOL":   0.25,
    "MATIC": 0.15,
    "BNB":   0.10,
    "AVAX":  0.10,
}

# Only rebalance if drift exceeds this threshold
DRIFT_THRESHOLD = 0.05        # 5%
MIN_PROFIT_USD  = 10.0        # only rebalance if net benefit > $10
MAX_BRIDGE_PCT  = 0.05        # max 5% of total portfolio per bridge tx
BATCH_WINDOW_S  = 21600       # 6 hours - accumulate before bridging

# Bridge fee rates (simplified; real implementation queries bridge APIs)
BRIDGE_FEES: Dict[Tuple[str, str], Dict] = {
    ("ETH",   "SOL"):   {"protocol": "wormhole",  "fee_pct": 0.0010, "base_usd": 2.50, "latency_s": 300},
    ("ETH",   "MATIC"): {"protocol": "stargate",  "fee_pct": 0.0006, "base_usd": 1.80, "latency_s": 90},
    ("ETH",   "BNB"):   {"protocol": "layerzero", "fee_pct": 0.0008, "base_usd": 2.00, "latency_s": 120},
    ("ETH",   "AVAX"):  {"protocol": "stargate",  "fee_pct": 0.0006, "base_usd": 1.80, "latency_s": 90},
    ("MATIC", "ETH"):   {"protocol": "across",    "fee_pct": 0.0005, "base_usd": 0.20, "latency_s": 60},
    ("BNB",   "ETH"):   {"protocol": "layerzero", "fee_pct": 0.0008, "base_usd": 0.50, "latency_s": 120},
    ("AVAX",  "ETH"):   {"protocol": "stargate",  "fee_pct": 0.0006, "base_usd": 0.30, "latency_s": 90},
    ("SOL",   "ETH"):   {"protocol": "wormhole",  "fee_pct": 0.0010, "base_usd": 0.001, "latency_s": 300},
}


# ─── Data Structures ────────────────────────────────────────────────────────

@dataclass
class ChainBalance:
    chain: str
    native_amount: Decimal
    usd_value: float
    last_updated: float = field(default_factory=time.time)


@dataclass
class RebalanceAction:
    from_chain: str
    to_chain: str
    amount_usd: float
    protocol: str
    estimated_fee_usd: float
    latency_seconds: int
    net_benefit_usd: float


# ─── Purple Flea Wallet API Client ──────────────────────────────────────────

class WalletAPIClient:
    def __init__(self, base_url: str, api_key: str):
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        }
        self._session: Optional[aiohttp.ClientSession] = None

    async def __aenter__(self):
        self._session = aiohttp.ClientSession(headers=self.headers)
        return self

    async def __aexit__(self, *args):
        await self._session.close()

    async def get_balances(self) -> Dict[str, ChainBalance]:
        """Fetch USD balances across all supported chains."""
        async with self._session.get(f"{self.base_url}/balances/all") as resp:
            resp.raise_for_status()
            data = await resp.json()

        balances = {}
        for chain, info in data["chains"].items():
            balances[chain] = ChainBalance(
                chain=chain,
                native_amount=Decimal(str(info["native_balance"])),
                usd_value=float(info["usd_value"]),
            )
        return balances

    async def bridge(
        self,
        from_chain: str,
        to_chain: str,
        amount_usd: float,
        protocol: str,
        slippage_bps: int = 30,
    ) -> Dict:
        """Execute cross-chain bridge via Purple Flea Wallet API."""
        payload = {
            "from_chain": from_chain,
            "to_chain": to_chain,
            "amount_usd": amount_usd,
            "protocol": protocol,
            "slippage_bps": slippage_bps,
            "asset": "USDC",
        }
        async with self._session.post(
            f"{self.base_url}/bridge", json=payload
        ) as resp:
            resp.raise_for_status()
            return await resp.json()


# ─── Rebalancing Logic ───────────────────────────────────────────────────────

class CrossChainRebalancer:
    def __init__(self, client: WalletAPIClient):
        self.client = client
        self.pending_actions: List[RebalanceAction] = []
        self.last_execution: float = 0

    def compute_drift(
        self, balances: Dict[str, ChainBalance]
    ) -> Dict[str, float]:
        """Compute how far each chain is from its target allocation."""
        total_usd = sum(b.usd_value for b in balances.values())
        if total_usd == 0:
            return {}

        drift = {}
        for chain, target in TARGET_ALLOCATION.items():
            actual = balances.get(chain)
            actual_pct = (actual.usd_value / total_usd) if actual else 0.0
            drift[chain] = actual_pct - target

        return drift

    def plan_rebalance(
        self,
        balances: Dict[str, ChainBalance],
        drift: Dict[str, float],
    ) -> List[RebalanceAction]:
        """Generate ordered list of rebalancing actions."""
        total_usd = sum(b.usd_value for b in balances.values())
        actions = []

        overweight  = {c: d for c, d in drift.items() if d >  DRIFT_THRESHOLD}
        underweight = {c: d for c, d in drift.items() if d < -DRIFT_THRESHOLD}

        for src_chain, src_drift in sorted(overweight.items(), key=lambda x: -x[1]):
            for dst_chain, dst_drift in sorted(underweight.items(), key=lambda x: x[1]):
                route_key = (src_chain, dst_chain)
                if route_key not in BRIDGE_FEES:
                    # Route via ETH as hub if direct not available
                    route_key = (src_chain, "ETH")
                    if route_key not in BRIDGE_FEES:
                        continue

                bridge = BRIDGE_FEES[route_key]
                amount_usd = min(
                    abs(src_drift) * total_usd,
                    abs(dst_drift) * total_usd,
                    MAX_BRIDGE_PCT * total_usd,
                )
                fee_usd = amount_usd * bridge["fee_pct"] + bridge["base_usd"]
                net_benefit = amount_usd * abs(dst_drift) - fee_usd

                if net_benefit < MIN_PROFIT_USD:
                    log.info(
                        f"Skip {src_chain}→{dst_chain}: net benefit ${net_benefit:.2f} below threshold"
                    )
                    continue

                actions.append(RebalanceAction(
                    from_chain=src_chain,
                    to_chain=dst_chain,
                    amount_usd=amount_usd,
                    protocol=bridge["protocol"],
                    estimated_fee_usd=fee_usd,
                    latency_seconds=bridge["latency_s"],
                    net_benefit_usd=net_benefit,
                ))

        return sorted(actions, key=lambda a: -a.net_benefit_usd)

    async def execute(self, dry_run: bool = False) -> List[Dict]:
        """Run a full rebalancing cycle."""
        now = time.time()
        if now - self.last_execution < BATCH_WINDOW_S:
            remaining = BATCH_WINDOW_S - (now - self.last_execution)
            log.info(f"Next rebalance in {remaining/3600:.1f}h")
            return []

        balances = await self.client.get_balances()
        total_usd = sum(b.usd_value for b in balances.values())
        log.info(f"Total portfolio: ${total_usd:,.2f}")

        drift = self.compute_drift(balances)
        for chain, d in drift.items():
            log.info(f"  {chain:6s} drift: {d:+.1%}")

        actions = self.plan_rebalance(balances, drift)
        log.info(f"Planned {len(actions)} rebalancing actions")

        results = []
        for action in actions:
            log.info(
                f"Bridge ${action.amount_usd:,.2f} {action.from_chain}→{action.to_chain}"
                f" via {action.protocol} (fee ${action.estimated_fee_usd:.2f},"
                f" net benefit ${action.net_benefit_usd:.2f})"
            )
            if not dry_run:
                result = await self.client.bridge(
                    from_chain=action.from_chain,
                    to_chain=action.to_chain,
                    amount_usd=action.amount_usd,
                    protocol=action.protocol,
                )
                results.append(result)
                log.info(f"  tx_hash: {result.get('tx_hash')}")
                # Pause between txs to avoid nonce collisions
                await asyncio.sleep(5)

        self.last_execution = time.time()
        return results


# ─── Main Loop ────────────────────────────────────────────────────────────────

async def main():
    async with WalletAPIClient(PURPLEFLEA_API, API_KEY) as client:
        rebalancer = CrossChainRebalancer(client)
        while True:
            try:
                await rebalancer.execute(dry_run=False)
            except Exception as e:
                log.error(f"Rebalance cycle failed: {e}")
            await asyncio.sleep(3600)  # Check every hour


if __name__ == "__main__":
    asyncio.run(main())

async def emergency_bridge(
    client: WalletAPIClient,
    from_chain: str,
    to_chain: str,
    amount_usd: float,
    reason: str,
) -> Dict:
    """
    Emergency bridge - ignores batch window and cost thresholds.
    Use only for liquidation risk, sweep to cold wallet, etc.
    Always uses fastest available route (liquidity network if possible).
    """
    log.warning(f"EMERGENCY BRIDGE: {reason}")
    log.warning(f"Moving ${amount_usd:,.2f} from {from_chain} to {to_chain}")

    # Find fastest route, prefer liquidity networks
    fast_protocols = ["across", "stargate", "layerzero", "wormhole"]
    route = BRIDGE_FEES.get((from_chain, to_chain))

    if not route:
        # Try via ETH hub
        hub_route = BRIDGE_FEES.get((from_chain, "ETH"))
        eth_dst   = BRIDGE_FEES.get(("ETH", to_chain))
        if not (hub_route and eth_dst):
            raise ValueError(f"No route found for {from_chain}→{to_chain}")
        # Two-hop bridge
        hop1 = await client.bridge(from_chain, "ETH", amount_usd, hub_route["protocol"])
        log.info(f"Hop 1 tx: {hop1['tx_hash']} — waiting {hub_route['latency_s']}s")
        await asyncio.sleep(hub_route["latency_s"] + 30)
        hop2 = await client.bridge("ETH", to_chain, amount_usd * 0.999, eth_dst["protocol"])
        log.info(f"Hop 2 tx: {hop2['tx_hash']}")
        return {"hops": [hop1, hop2], "status": "two_hop"}

    return await client.bridge(
        from_chain, to_chain, amount_usd,
        protocol=route["protocol"],
        slippage_bps=50,  # Wider slippage for emergency
    )