AI Agent Treasury Management: Diversification and Rebalancing

import numpy as np
import httpx
import asyncio
from dataclasses import dataclass, field
from typing import Dict, List, Tuple
from datetime import datetime, timedelta

WALLET_API = "https://purpleflea.com/wallet-api"
TRADING_API = "https://purpleflea.com/trading-api"
API_KEY = "your_pf_api_key"

# Target allocation: {asset: fraction}
TARGET_ALLOCATION = {
    "USDC": 0.40,
    "ETH":  0.30,
    "BTC":  0.20,
    "SOL":  0.07,
    "LINK": 0.03,
}

# Rebalancing triggers
DRIFT_THRESHOLD = 0.05    # rebalance if any asset drifts >5% from target
MAX_VAR_PCT     = 0.05    # halt if 1-day VaR exceeds 5% of NAV
MIN_SHARPE      = 0.80    # warn if 30-day Sharpe falls below 0.8

@dataclass
class TreasurySnapshot:
    timestamp: datetime
    balances: Dict[str, float]     # {asset: amount_in_usd}
    total_nav: float
    weights: Dict[str, float]      # {asset: fraction}
    drift: Dict[str, float]        # {asset: actual - target}

async def fetch_balances(wallet: str) -> Dict[str, float]:
    """Fetch wallet balances in USD from Purple Flea Wallet API."""
    async with httpx.AsyncClient() as client:
        res = await client.get(
            f"{WALLET_API}/v1/balances",
            params={"wallet": wallet, "currency": "USD"},
            headers={"X-API-Key": API_KEY}
        )
    return {b["asset"]: b["usd_value"] for b in res.json()["balances"]}

def compute_snapshot(balances: Dict[str, float]) -> TreasurySnapshot:
    total = sum(balances.values())
    weights = {a: v/total for a, v in balances.items()}
    drift = {
        a: weights.get(a, 0) - TARGET_ALLOCATION.get(a, 0)
        for a in set(list(weights) + list(TARGET_ALLOCATION))
    }
    return TreasurySnapshot(
        timestamp=datetime.utcnow(),
        balances=balances,
        total_nav=total,
        weights=weights,
        drift=drift
    )

def needs_rebalance(snap: TreasurySnapshot) -> bool:
    """True if any asset has drifted beyond DRIFT_THRESHOLD."""
    return any(abs(d) > DRIFT_THRESHOLD for d in snap.drift.values())

def compute_rebalance_trades(snap: TreasurySnapshot) -> List[Tuple[str, str, float]]:
    """Generate (sell_asset, buy_asset, usd_amount) trades to restore targets.
    Pairs sells with buys to minimize trades (sell overweight, buy underweight).
    """
    nav = snap.total_nav
    sells = {}  # assets to sell: {asset: usd_surplus}
    buys  = {}  # assets to buy:  {asset: usd_deficit}

    for asset, target_wt in TARGET_ALLOCATION.items():
        actual_usd = snap.balances.get(asset, 0)
        target_usd = nav * target_wt
        delta = actual_usd - target_usd
        if delta > 10:   # >$10 overweight — sell
            sells[asset] = delta
        elif delta < -10: # >$10 underweight — buy
            buys[asset] = -delta

    trades = []
    sell_items = list(sells.items())
    buy_items  = list(buys.items())
    si, bi = 0, 0

    # Greedy match: pair largest sells with largest buys
    while si < len(sell_items) and bi < len(buy_items):
        sell_asset, sell_amt = sell_items[si]
        buy_asset,  buy_amt  = buy_items[bi]
        trade_amt = min(sell_amt, buy_amt)
        trades.append((sell_asset, buy_asset, round(trade_amt, 2)))
        sell_items[si] = (sell_asset, sell_amt - trade_amt)
        buy_items[bi]  = (buy_asset,  buy_amt  - trade_amt)
        if sell_items[si][1] < 1: si += 1
        if buy_items[bi][1]  < 1: bi += 1

    return trades

def compute_sharpe(daily_returns: np.ndarray, rf_daily: float = 0.00015) -> float:
    """Annualized Sharpe ratio from daily return array."""
    excess = daily_returns - rf_daily
    if excess.std() == 0:
        return 0.0
    return float((excess.mean() / excess.std()) * np.sqrt(365))

def compute_var(
    daily_returns: np.ndarray,
    nav: float,
    confidence: float = 0.95
) -> float:
    """Historical simulation 1-day VaR in USD."""
    percentile = np.percentile(daily_returns, (1 - confidence) * 100)
    return abs(percentile * nav)

async def execute_trades(trades: List[Tuple[str, str, float]], wallet: str):
    """Execute rebalancing trades via Purple Flea Trading API."""
    async with httpx.AsyncClient() as client:
        for sell_asset, buy_asset, usd_amount in trades:
            print(f"Selling ${usd_amount:.2f} of {sell_asset} → {buy_asset}")
            res = await client.post(
                f"{TRADING_API}/v1/swap",
                json={
                    "wallet": wallet,
                    "from_asset": sell_asset,
                    "to_asset": buy_asset,
                    "from_usd_amount": usd_amount,
                    "slippage_tolerance": 0.003,
                    "routing": "best_price"
                },
                headers={"X-API-Key": API_KEY}
            )
            result = res.json()
            print(f"  Trade result: {result['status']} — {result.get('tx_hash', '')[:16]}...")

async def run_treasury_manager(wallet: str, history_days: int = 30):
    while True:
        balances = await fetch_balances(wallet)
        snap = compute_snapshot(balances)

        print(f"\n[{snap.timestamp.isoformat()}] NAV: ${snap.total_nav:,.2f}")
        for asset, wt in snap.weights.items():
            drift = snap.drift.get(asset, 0)
            flag = "  WARNING: large drift" if abs(drift) > DRIFT_THRESHOLD else ""
            print(f"  {asset:6s}: {wt*100:.1f}% (target {TARGET_ALLOCATION.get(asset,0)*100:.0f}%, drift {drift*100:+.1f}%){flag}")

        if needs_rebalance(snap):
            trades = compute_rebalance_trades(snap)
            print(f"Rebalancing: {len(trades)} trade(s)")
            await execute_trades(trades, wallet)
        else:
            print("Portfolio within tolerance — no rebalance needed")

        await asyncio.sleep(3600)  # check every hour

asyncio.run(run_treasury_manager("0xYourAgentWallet"))

import httpx from 'httpx'

const PF_WALLET = 'https://purpleflea.com/wallet-api'
const API_KEY   = 'your_api_key'

/**
 * Compute portfolio-level metrics from price history.
 * @param {Object} weightedPriceHistory - {asset: [daily_prices]}
 * @param {Object} currentWeights - {asset: fraction}
 */
function computePortfolioMetrics(weightedPriceHistory, currentWeights) {
  const assets = Object.keys(currentWeights)
  const nDays = Object.values(weightedPriceHistory)[0].length - 1

  // Daily portfolio returns
  const portfolioReturns = []
  for (let i = 1; i <= nDays; i++) {
    let dayReturn = 0
    for (const asset of assets) {
      const prices = weightedPriceHistory[asset]
      const assetReturn = (prices[i] - prices[i-1]) / prices[i-1]
      dayReturn += assetReturn * (currentWeights[asset] || 0)
    }
    portfolioReturns.push(dayReturn)
  }

  // Sharpe ratio (annualized)
  const rfDaily = 0.055 / 365
  const mean = portfolioReturns.reduce((a, b) => a + b, 0) / portfolioReturns.length
  const variance = portfolioReturns.reduce((s, r) => s + Math.pow(r - mean, 2), 0) / portfolioReturns.length
  const stdDev = Math.sqrt(variance)
  const sharpe = ((mean - rfDaily) / stdDev) * Math.sqrt(365)

  // 1-day VaR at 95% confidence (historical simulation)
  const sorted = [...portfolioReturns].sort((a, b) => a - b)
  const varIndex = Math.floor(sorted.length * 0.05)
  const var95 = Math.abs(sorted[varIndex])

  // Max drawdown
  let peak = -Infinity, maxDD = 0, running = 1
  for (const r of portfolioReturns) {
    running *= (1 + r)
    if (running > peak) peak = running
    const dd = (peak - running) / peak
    if (dd > maxDD) maxDD = dd
  }

  return {
    sharpe: sharpe.toFixed(3),
    var95Pct: (var95 * 100).toFixed(2) + '%',
    maxDrawdown: (maxDD * 100).toFixed(2) + '%',
    annualizedReturn: (mean * 365 * 100).toFixed(1) + '%',
    volatility30d: (stdDev * Math.sqrt(365) * 100).toFixed(1) + '%'
  }
}

async function runRiskCheck(wallet) {
  const res = await fetch(`${PF_WALLET}/v1/treasury/metrics`, {
    headers: { 'X-API-Key': API_KEY },
    body: JSON.stringify({ wallet }),
    method: 'POST'
  })
  const { priceHistory, currentWeights, nav } = await res.json()

  const metrics = computePortfolioMetrics(priceHistory, currentWeights)
  console.log('=== Treasury Risk Report ===')
  console.log(`NAV: $${nav.toLocaleString()}`)
  console.log(`Sharpe:         ${metrics.sharpe}`)
  console.log(`1-Day VaR 95%:  ${metrics.var95Pct}`)
  console.log(`Max Drawdown:   ${metrics.maxDrawdown}`)
  console.log(`Annual Return:  ${metrics.annualizedReturn}`)
  console.log(`Volatility:     ${metrics.volatility30d}`)

  const varUSD = parseFloat(metrics.var95Pct) / 100 * nav
  if (varUSD > nav * 0.05) {
    console.warn(`ALERT: VaR ($${varUSD.toFixed(0)}) exceeds 5% of NAV — reducing risk exposure`)
  }
}

runRiskCheck('0xYourAgentWallet')