Your agent as a
robo-advisor

// Purple Flea Agent Robo-Advisor
// Monitors 6 services, rebalances on drift or schedule

import fetch from 'node-fetch';

const BASE = 'https://purpleflea.com/api';
const ESCROW_BASE = 'https://escrow.purpleflea.com/api';

class RoboAdvisor {
  constructor(apiKey, config = {}) {
    this.apiKey = apiKey;
    this.targets = config.targets ?? {
      casino:  15,  // % of portfolio
      trading: 30,
      wallet:  25,
      escrow:  20,
      domains: 10,
      faucet:  0,   // not a storage service
    };
    this.driftThreshold  = config.driftThreshold  ?? 10; // %
    this.intervalMs      = config.intervalMs      ?? 3_600_000; // 1h
    this.maxDrawdown     = config.maxDrawdown     ?? 25; // %
    this.peakValue       = 0;
    this.safeMode        = false;
    this.log             = [];
  }

  async getBalances() {
    const headers = { 'Authorization': `Bearer ${this.apiKey}` };
    const [casino, trading, wallet, escrow, domains] = await Promise.all([
      fetch(`${BASE}/casino/balance`,   { headers }).then(r => r.json()),
      fetch(`${BASE}/trading/portfolio`, { headers }).then(r => r.json()),
      fetch(`${BASE}/wallet/balance`,   { headers }).then(r => r.json()),
      fetch(`${ESCROW_BASE}/balance`,   { headers }).then(r => r.json()),
      fetch(`${BASE}/domains/list`,     { headers }).then(r => r.json()),
    ]);
    return {
      casino:  casino.balance           ?? 0,
      trading: trading.totalValue       ?? 0,
      wallet:  wallet.balance           ?? 0,
      escrow:  escrow.lockedBalance     ?? 0,
      domains: domains.portfolioValue  ?? 0,
    };
  }

  detectDrift(balances, total) {
    const drifts = {};
    for (const [svc, bal] of Object.entries(balances)) {
      const current = total > 0 ? (bal / total) * 100 : 0;
      drifts[svc] = Math.abs(current - (this.targets[svc] ?? 0));
    }
    return drifts;
  }

  async rebalance(balances, total) {
    const moves = [];
    for (const [svc, target] of Object.entries(this.targets)) {
      const targetAmt = ((target / 100) * total);
      const delta     = targetAmt - (balances[svc] ?? 0);
      if (Math.abs(delta) > 0.01) moves.push({ svc, delta });
    }
    // Execute withdrawals first, then deposits
    const withdrawals = moves.filter(m => m.delta < 0);
    const deposits    = moves.filter(m => m.delta > 0);
    for (const { svc, delta } of [...withdrawals, ...deposits]) {
      await this.move(svc, delta);
    }
    this.emit('rebalanced', { moves, total, ts: new Date().toISOString() });
  }

  async move(service, deltaUsd) {
    // Positive delta = deposit to service
    // Negative delta = withdraw from service to wallet
    const endpoint = deltaUsd > 0
      ? `${BASE}/${service}/deposit`
      : `${BASE}/${service}/withdraw`;
    return fetch(endpoint, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ amount: Math.abs(deltaUsd) }),
    }).then(r => r.json());
  }

  async tick() {
    if (this.safeMode) { console.log('[RoboAdvisor] Safe mode — skipping tick'); return; }
    const balances = await this.getBalances();
    const total    = Object.values(balances).reduce((a, b) => a + b, 0);

    // Drawdown check
    if (total > this.peakValue) this.peakValue = total;
    const drawdown = this.peakValue > 0
      ? ((this.peakValue - total) / this.peakValue) * 100
      : 0;
    if (drawdown >= this.maxDrawdown) {
      console.warn(`[RoboAdvisor] Max drawdown reached (${drawdown.toFixed(1)}%) — entering safe mode`);
      this.safeMode = true;
      return;
    }

    // Drift check
    const drifts     = this.detectDrift(balances, total);
    const needsRebal = Object.values(drifts).some(d => d > this.driftThreshold);
    if (needsRebal) await this.rebalance(balances, total);
  }

  start() {
    this.tick(); // run immediately
    this._timer = setInterval(() => this.tick(), this.intervalMs);
    console.log(`[RoboAdvisor] Started — polling every ${this.intervalMs / 60000}m`);
  }

  stop()  { clearInterval(this._timer); }
  emit(ev, data) { this.log.push({ ev, data }); console.log(`[${ev}]`, data); }
}

// Usage
const advisor = new RoboAdvisor('pf_live_YOUR_KEY', {
  targets:        { casino: 15, trading: 30, wallet: 25, escrow: 20, domains: 10 },
  driftThreshold: 10,
  intervalMs:     3_600_000,
  maxDrawdown:    25,
});
advisor.start();