Collateral Management for AI Agents: Cross-Chain Lending and Borrowing in 2026

import httpx
from web3 import Web3
from decimal import Decimal

# Aave v3 mainnet addresses
AAVE_POOL = "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2"
WETH_GATEWAY = "0xD322A49006FC828F9B5B37Ab215F99B4E5caB19C"
USDC_MAINNET = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"

class AaveCollateralManager:
    def __init__(self, w3: Web3, wallet_address: str, private_key: str):
        self.w3 = w3
        self.wallet = wallet_address
        self.key = private_key
        self.pool = self.w3.eth.contract(address=AAVE_POOL, abi=AAVE_POOL_ABI)

    async def deposit_eth_collateral(self, amount_eth: float) -> str:
        """Deposit ETH into Aave v3 as collateral via WETHGateway."""
        gateway = self.w3.eth.contract(address=WETH_GATEWAY, abi=GATEWAY_ABI)
        amount_wei = self.w3.to_wei(amount_eth, "ether")

        tx = gateway.functions.depositETH(
            AAVE_POOL, self.wallet, 0
        ).build_transaction({
            "from": self.wallet,
            "value": amount_wei,
            "gas": 300_000,
            "maxFeePerGas": self.w3.eth.gas_price * 2,
        })
        signed = self.w3.eth.account.sign_transaction(tx, self.key)
        tx_hash = self.w3.eth.send_raw_transaction(signed.rawTransaction)
        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
        return receipt["transactionHash"].hex()

    async def borrow_usdc(self, amount_usdc: float) -> str:
        """Borrow USDC against ETH collateral. InterestRateMode 2 = variable."""
        amount_units = int(amount_usdc * 10**6)
        tx = self.pool.functions.borrow(
            USDC_MAINNET, amount_units, 2, 0, self.wallet
        ).build_transaction({
            "from": self.wallet,
            "gas": 400_000,
        })
        signed = self.w3.eth.account.sign_transaction(tx, self.key)
        tx_hash = self.w3.eth.send_raw_transaction(signed.rawTransaction)
        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
        return receipt["transactionHash"].hex()

    async def get_health_factor(self) -> float:
        """Returns current health factor. Below 1.0 = liquidatable."""
        data = self.pool.functions.getUserAccountData(self.wallet).call()
        # data[5] = healthFactor in 1e18 units
        return float(data[5]) / 1e18

import asyncio
import httpx
from web3 import Web3
from dataclasses import dataclass
from typing import Dict, Optional

PURPLE_FLEA_API = "https://api.purpleflea.com/v1"

@dataclass
class AgentFinancialState:
    wallet_balances: Dict[str, float]
    aave_collateral_usd: float
    aave_debt_usd: float
    aave_health_factor: float
    pf_open_positions_usd: float
    net_equity_usd: float
    available_borrow_usd: float

class CollateralManager:
    def __init__(
        self,
        wallet_address: str,
        api_key: str,
        w3_mainnet: Web3,
        w3_arbitrum: Web3,
        min_health_factor: float = 1.25,
        target_health_factor: float = 1.5,
        reserve_ratio: float = 0.12
    ):
        self.wallet = wallet_address
        self.api_key = api_key
        self.w3m = w3_mainnet
        self.w3a = w3_arbitrum
        self.min_hf = min_health_factor
        self.target_hf = target_health_factor
        self.reserve_ratio = reserve_ratio
        self.aave_pool = w3_mainnet.eth.contract(
            address=AAVE_POOL, abi=AAVE_POOL_ABI
        )

    async def get_state(self) -> AgentFinancialState:
        """Aggregate full financial picture from wallet API + Aave."""
        async with httpx.AsyncClient() as client:
            # Fetch wallet balances from Purple Flea API
            resp = await client.get(
                f"{PURPLE_FLEA_API}/wallet/balances",
                headers={"X-API-Key": self.api_key},
                params={"address": self.wallet, "chains": "ethereum,arbitrum,base"}
            )
            balances = resp.json()["balances"]

            # Fetch open positions
            pos_resp = await client.get(
                f"{PURPLE_FLEA_API}/trading/positions",
                headers={"X-API-Key": self.api_key},
                params={"address": self.wallet}
            )
            positions = pos_resp.json()["positions"]
            pf_usd = sum(p["notional_usd"] for p in positions)

        # Read Aave position directly from contract (free RPC call)
        aave_data = self.aave_pool.functions.getUserAccountData(self.wallet).call()
        collateral_usd = aave_data[0] / 1e8  # Aave uses 8 decimals for USD
        debt_usd = aave_data[1] / 1e8
        available_borrow = aave_data[2] / 1e8
        hf = aave_data[5] / 1e18

        net_equity = collateral_usd - debt_usd + sum(
            b["usd_value"] for b in balances
        )

        return AgentFinancialState(
            wallet_balances={b["token"]: b["usd_value"] for b in balances},
            aave_collateral_usd=collateral_usd,
            aave_debt_usd=debt_usd,
            aave_health_factor=hf,
            pf_open_positions_usd=pf_usd,
            net_equity_usd=net_equity,
            available_borrow_usd=available_borrow
        )

    async def rebalance(self, state: AgentFinancialState):
        """Called every 60s. Checks HF and triggers actions if needed."""
        hf = state.aave_health_factor
        if hf <= 0:  # No debt, nothing to monitor
            return

        if hf < 1.05:
            await self.emergency_unwind(state)
        elif hf < self.min_hf:
            await self.add_collateral_or_repay(state)
        elif hf > 2.5 and state.available_borrow_usd > 500:
            # Too conservative; borrow more to deploy
            await self.increase_leverage(state)

    async def monitor_loop(self, interval_seconds: int = 60):
        """Main monitoring loop. Run as a background asyncio task."""
        while True:
            try:
                state = await self.get_state()
                await self.rebalance(state)
                await asyncio.sleep(interval_seconds)
            except Exception as e:
                print(ff"CollateralManager error: {e}")
                await asyncio.sleep(30)  # Retry faster after error

import asyncio
import logging
from enum import Enum

class RebalanceAction(Enum):
    NONE = "none"
    ADD_COLLATERAL = "add_collateral"
    REPAY_DEBT = "repay_debt"
    EMERGENCY_UNWIND = "emergency_unwind"
    INCREASE_LEVERAGE = "increase_leverage"

class CollateralRebalancer:
    """
    Monitors Aave health factor and rebalances to maintain
    target_hf. Integrates with Purple Flea for position data.
    """

    def __init__(
        self,
        aave_manager,         # AaveCollateralManager instance
        pf_client,            # Purple Flea API client
        bridge_client,        # Bridge client (Across Protocol)
        min_hf: float = 1.25,
        target_hf: float = 1.5,
        emergency_hf: float = 1.05
    ):
        self.aave = aave_manager
        self.pf = pf_client
        self.bridge = bridge_client
        self.min_hf = min_hf
        self.target_hf = target_hf
        self.emergency_hf = emergency_hf
        self.log = logging.getLogger("CollateralRebalancer")

    def decide_action(self, hf: float, available_eth: float) -> RebalanceAction:
        """Stateless decision function - easy to test."""
        if hf <= self.emergency_hf:
            return RebalanceAction.EMERGENCY_UNWIND
        elif hf < self.min_hf and available_eth > 0.05:
            return RebalanceAction.ADD_COLLATERAL
        elif hf < self.min_hf:
            return RebalanceAction.REPAY_DEBT
        elif hf > 2.5:
            return RebalanceAction.INCREASE_LEVERAGE
        return RebalanceAction.NONE

    def calculate_collateral_needed(
        self,
        current_hf: float,
        collateral_usd: float,
        debt_usd: float,
        lt: float = 0.83
    ) -> float:
        """
        How much more collateral (in USD) to add to reach target_hf?
        target_hf = (collateral_usd + X) * lt / debt_usd
        X = target_hf * debt_usd / lt - collateral_usd
        """
        needed_usd = (self.target_hf * debt_usd / lt) - collateral_usd
        return max(0, needed_usd)

    def calculate_repay_needed(
        self,
        collateral_usd: float,
        debt_usd: float,
        lt: float = 0.83
    ) -> float:
        """
        How much debt to repay to reach target_hf?
        target_hf = collateral_usd * lt / (debt_usd - X)
        X = debt_usd - collateral_usd * lt / target_hf
        """
        new_debt = collateral_usd * lt / self.target_hf
        return max(0, debt_usd - new_debt)

    async def execute_rebalance(self, state):
        hf = state.aave_health_factor
        available_eth = state.wallet_balances.get("ETH", 0) / 3400  # USD to ETH
        action = self.decide_action(hf, available_eth)

        if action == RebalanceAction.NONE:
            return

        self.log.info(ff"Rebalance triggered: HF={hf:.3f}, Action={action.value}")

        if action == RebalanceAction.ADD_COLLATERAL:
            needed_usd = self.calculate_collateral_needed(
                hf, state.aave_collateral_usd, state.aave_debt_usd
            )
            eth_to_add = (needed_usd / 3400) * 1.05  # 5% buffer
            eth_to_add = min(eth_to_add, available_eth * 0.8)  # Don't drain wallet
            tx = await self.aave.deposit_eth_collateral(eth_to_add)
            self.log.info(ff"Added {eth_to_add:.4f} ETH collateral. TX: {tx}")

        elif action == RebalanceAction.REPAY_DEBT:
            # Close part of Purple Flea position to get USDC for repayment
            repay_usd = self.calculate_repay_needed(
                state.aave_collateral_usd, state.aave_debt_usd
            )
            await self.pf.close_partial_position(repay_usd * 1.05)
            await asyncio.sleep(30)  # Wait for bridged funds
            tx = await self.aave.repay_usdc(repay_usd)
            self.log.info(ff"Repaid ${repay_usd:.2f} USDC. TX: {tx}")

        elif action == RebalanceAction.EMERGENCY_UNWIND:
            self.log.warning("EMERGENCY UNWIND TRIGGERED")
            await self.pf.close_all_positions()
            await asyncio.sleep(120)  # Wait for bridge settlement
            full_debt = state.aave_debt_usd * 1.01  # 1% buffer for accrued interest
            await self.aave.repay_usdc(full_debt)
            await self.aave.withdraw_all_collateral()
            self.log.warning("Emergency unwind complete.")

        elif action == RebalanceAction.INCREASE_LEVERAGE:
            available = state.available_borrow_usd * 0.5  # Only take 50% of available
            if available > 500:
                tx = await self.aave.borrow_usdc(available)
                await self.bridge.bridge_to_arbitrum(available * 0.88)  # Keep 12% reserve
                self.log.info(ff"Borrowed ${available:.2f} more USDC for deployment")