DeFi for AI Agents:
Yield Farming, Lending, and Liquidity in 2026

import httpx
from dataclasses import dataclass

WALLET_API = "https://purpleflea.com/api/wallet"
API_KEY    = "pf_live_your_key_here"

class PFWalletClient:
    def __init__(self, api_key: str):
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type":  "application/json",
        }
        self.client = httpx.AsyncClient(base_url=WALLET_API, headers=self.headers)

    async def get_balance(self, chain: str = "ethereum") -> dict:
        r = await self.client.get(f"/balance?chain={chain}")
        return r.json()

    async def bridge_to_chain(self, asset: str, amount: float, dest_chain: str) -> dict:
        r = await self.client.post("/bridge", json={
            "asset": asset, "amount": amount, "destChain": dest_chain
        })
        return r.json()

    async def sign_transaction(self, tx_data: dict) -> dict:
        """Sign and broadcast a transaction. Returns txHash."""
        r = await self.client.post("/sign-and-send", json=tx_data)
        return r.json()

    async def withdraw_to_defi(self, protocol: str, amount: float, asset: str) -> dict:
        """Move capital from Purple Flea to a DeFi protocol."""
        r = await self.client.post("/defi/deposit", json={
            "protocol": protocol, "amount": amount, "asset": asset
        })
        return r.json()

wallet = PFWalletClient(API_KEY)

import asyncio

AAVE_POOL = "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2"  # Ethereum mainnet

async def deposit_to_aave(wallet_client, amount_usdc: float):
    # Step 1: Check current wallet balance on Purple Flea
    balance = await wallet_client.get_balance("ethereum")
    usdc_balance = balance["USDC"]
    print(f"PF Wallet USDC balance: ${usdc_balance:.2f}")

    if usdc_balance < amount_usdc:
        raise ValueError(f"Insufficient balance: have ${usdc_balance}, need ${amount_usdc}")

    # Step 2: Bridge capital to Ethereum mainnet (if needed)
    # Step 3: Call Aave supply() via PF Wallet transaction signing
    tx = {
        "to":    AAVE_POOL,
        "chain": "ethereum",
        "method": "supply",
        "params": {
            "asset":       "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",  # USDC
            "amount":      int(amount_usdc * 1e6),  # USDC has 6 decimals
            "onBehalfOf": "YOUR_AGENT_ADDRESS",
            "referralCode": 0
        }
    }
    result = await wallet_client.sign_transaction(tx)
    print(f"Deposited ${amount_usdc} USDC to Aave. TxHash: {result['txHash']}")
    return result

async def monitor_aave_yield(wallet_client, interval_hours: int = 6):
    """Poll Aave position and auto-compound every N hours."""
    while True:
        r = await wallet_client.get_balance("ethereum")
        aUsdc_balance = r.get("aUSDC", 0)  # aUSDC accrues automatically
        print(f"Aave aUSDC balance: ${aUsdc_balance:.4f} (includes accrued interest)")
        await asyncio.sleep(interval_hours * 3600)

# Run both concurrently
async def main():
    await deposit_to_aave(wallet, 50.0)
    await monitor_aave_yield(wallet)

asyncio.run(main())

import asyncio, httpx

AAVE_SUBGRAPH = "https://api.thegraph.com/subgraphs/name/aave/protocol-v3"

async def get_at_risk_positions(health_factor_max: float = 1.05) -> list:
    """Query Aave subgraph for undercollateralized positions."""
    query = """
    {
      users(
        where: { healthFactor_lt: "1050000000000000000" }
        first: 10
        orderBy: healthFactor
        orderDirection: asc
      ) {
        id
        healthFactor
        totalCollateralBase
        totalDebtBase
        collateralReserves { reserve { symbol underlyingAsset liquidationBonus } amount }
        borrowReserves    { reserve { symbol underlyingAsset } currentTotalDebt }
      }
    }
    """
    async with httpx.AsyncClient() as client:
        r = await client.post(AAVE_SUBGRAPH, json={"query": query})
        return r.json()["data"]["users"]

async def execute_liquidation(wallet_client, position: dict):
    """Execute liquidation call via Purple Flea Wallet."""
    collateral = position["collateralReserves"][0]
    borrow     = position["borrowReserves"][0]
    bonus_pct  = collateral["reserve"]["liquidationBonus"] / 10000 - 1

    tx = {
        "to":     "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2",
        "chain":  "ethereum",
        "method": "liquidationCall",
        "params": {
            "collateralAsset": collateral["reserve"]["underlyingAsset"],
            "debtAsset":       borrow["reserve"]["underlyingAsset"],
            "user":            position["id"],
            "debtToCover":     int(float(position["totalDebtBase"]) * 0.5),
            "receiveAToken":   False
        }
    }
    result = await wallet_client.sign_transaction(tx)
    print(f"Liquidated {position['id'][:8]}... Bonus: {bonus_pct:.1%} | Tx: {result['txHash']}")
    return result

async def liquidation_bot_loop(wallet_client):
    while True:
        positions = await get_at_risk_positions()
        for pos in positions:
            try:
                await execute_liquidation(wallet_client, pos)
            except Exception as e:
                print(f"Liquidation failed: {e}")
        await asyncio.sleep(12)  # Check every ~1 Ethereum block

from decimal import Decimal
import asyncio, httpx, math

class UniswapV3Manager:
    def __init__(self, wallet_client, pool_address: str, fee_tier: int):
        self.wallet  = wallet_client
        self.pool    = pool_address
        self.fee     = fee_tier  # 500 = 0.05%, 3000 = 0.3%, 10000 = 1%

    async def get_current_price(self) -> float:
        r = await httpx.get(
            f"https://purpleflea.com/api/wallet/defi/uniswap/price",
            params={"pool": self.pool},
            headers=self.wallet.headers
        )
        return r.json()["price"]

    def compute_range(self, current_price: float, range_pct: float = 0.1) -> tuple:
        """Compute tick range centered on current price ± range_pct."""
        lower = current_price * (1 - range_pct)
        upper = current_price * (1 + range_pct)
        # Convert price to tick (tick = log(price) / log(1.0001))
        tick_lower = int(math.log(lower) / math.log(1.0001))
        tick_upper = int(math.log(upper) / math.log(1.0001))
        return tick_lower, tick_upper

    async def rebalance(self, position_id: int, usdc_amount: float):
        """Remove old position and add new one centered on current price."""
        price = await self.get_current_price()
        tick_lower, tick_upper = self.compute_range(price, range_pct=0.08)

        # Remove existing position
        await self.wallet.sign_transaction({
            "to": "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",  # NonfungiblePositionManager
            "method": "decreaseLiquidity",
            "params": {"tokenId": position_id, "liquidity": "MAX", "deadline": 9999999999}
        })

        # Add new position at current price range
        result = await self.wallet.sign_transaction({
            "to": "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
            "method": "mint",
            "params": {
                "tickLower": tick_lower, "tickUpper": tick_upper,
                "amount0Desired": int(usdc_amount * 0.5 * 1e6),
                "amount1Desired": int(usdc_amount * 0.5 * 1e18),  # paired with ETH
                "deadline": 9999999999
            }
        })
        print(f"Rebalanced LP at price ${price:.2f} | Range: ${lower:.2f}–${upper:.2f}")
        return result

    async def auto_rebalance_loop(self, position_id: int, usdc_amount: float,
                                   check_interval: int = 300,
                                   rebalance_threshold: float = 0.06):
        last_price = await self.get_current_price()
        while True:
            price = await self.get_current_price()
            deviation = abs(price - last_price) / last_price
            if deviation > rebalance_threshold:
                print(f"Price moved {deviation:.1%} — rebalancing position...")
                await self.rebalance(position_id, usdc_amount)
                last_price = price
            await asyncio.sleep(check_interval)

import asyncio, httpx

DEXES = {
    "uniswap_v3":  "https://api.uniswap.org/v1/quote",
    "sushiswap":   "https://api.sushi.com/price",
    "curve":       "https://api.curve.fi/api/getPrices",
}

async def get_quote(dex: str, token_in: str, token_out: str, amount: float) -> float:
    """Fetch swap quote from DEX. Returns output amount."""
    async with httpx.AsyncClient() as client:
        r = await client.get(DEXES[dex], params={
            "tokenIn": token_in, "tokenOut": token_out, "amount": str(amount)
        })
        return float(r.json()["quote"])

async def find_arb(token_a: str, token_b: str, capital: float) -> dict | None:
    """Find arbitrage between all DEX pairs. Returns best opportunity."""
    quotes = {}
    for dex in DEXES:
        try:
            quotes[dex] = await get_quote(dex, token_a, token_b, capital)
        except:
            pass

    if len(quotes) < 2: return None

    best_buy   = min(quotes, key=lambda d: capital / quotes[d])  # cheapest price
    best_sell  = max(quotes, key=lambda d: quotes[d])             # highest output
    profit_pct = (quotes[best_sell] - quotes[best_buy]) / quotes[best_buy]

    if profit_pct > 0.003:  # 0.3% minimum profit threshold
        return {
            "buy_on":     best_buy,
            "sell_on":    best_sell,
            "profit_pct": profit_pct,
            "profit_usd": capital * profit_pct,
        }
    return None

async def arb_monitor():
    while True:
        opp = await find_arb("USDC", "WETH", 1000)
        if opp:
            print(f"ARB: buy on {opp['buy_on']}, sell on {opp['sell_on']}")
            print(f"     profit: {opp['profit_pct']:.2%} (${opp['profit_usd']:.2f})")
            # Execute via Purple Flea Wallet + Flashbots bundle...
        await asyncio.sleep(2)

CHAIN_YIELDS = {
    "ethereum": 0.07,  # 7% APY on Aave
    "arbitrum": 0.11,  # 11% APY on GMX/Beefy
    "base":     0.09,  # 9% APY on Aerodrome
    "polygon":  0.06,  # 6% APY on Quickswap
}

async def rebalance_to_best_chain(wallet_client, asset: str = "USDC"):
    """Move assets to the highest-yielding chain."""
    # In production, fetch live APY from on-chain data
    best_chain = max(CHAIN_YIELDS, key=CHAIN_YIELDS.get)
    best_apy   = CHAIN_YIELDS[best_chain]

    # Get balances across all chains
    balances = {}
    for chain in CHAIN_YIELDS:
        bal = await wallet_client.get_balance(chain)
        balances[chain] = bal.get(asset, 0)

    # Bridge non-optimal chain balances to best chain
    for chain, amount in balances.items():
        if chain != best_chain and amount > 10:  # only bridge if >$10 (gas efficiency)
            yield_diff = best_apy - CHAIN_YIELDS[chain]
            if yield_diff > 0.02:  # only bridge if >2% yield improvement
                print(f"Bridging ${amount:.2f} {asset} from {chain} → {best_chain}")
                print(f"Yield gain: {yield_diff:.1%} APY")
                result = await wallet_client.bridge_to_chain(asset, amount, best_chain)
                print(f"Bridge initiated: {result['bridgeId']}")