Multi-Chain Wallet
8 chains, one API

const WALLET = 'https://purpleflea.com/api/wallet';
const API_KEY = process.env.PF_API_KEY;

const headers = {
  'Authorization': `Bearer ${API_KEY}`,
  'Content-Type': 'application/json'
};

async function generateWallet() {
  const res = await fetch(`${WALLET}/generate`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      chains: ['ETH', 'SOL', 'BTC', 'XMR', 'TRX', 'MATIC', 'BNB', 'AVAX'],
      label: 'main-treasury'   // optional label
    })
  });

  const wallet = await res.json();

  // Print addresses for all chains
  for (const [chain, info] of Object.entries(wallet.addresses)) {
    console.log(`${chain.padEnd(6)}: ${info.address}`);
  }

  console.log(`\nWallet ID: ${wallet.wallet_id}`);
  // Store wallet_id for subsequent calls
  return wallet;
}

generateWallet();

async function getPortfolio() {
  const res = await fetch(`${WALLET}/balances`, { headers });
  const portfolio = await res.json();

  let totalUSD = 0;

  console.log('=== Agent Portfolio ===');
  console.log('Chain   | Native        | USDC      | USD Value');
  console.log('--------|---------------|-----------|----------');

  for (const chain of portfolio.chains) {
    const native = chain.native_balance.toFixed(4).padEnd(13);
    const usdc   = chain.usdc_balance.toFixed(2).padEnd(9);
    const usd    = chain.usd_value.toFixed(2);
    console.log(`${chain.symbol.padEnd(7)} | ${native} | ${usdc} | $${usd}`);
    totalUSD += chain.usd_value;
  }

  console.log(`\nTotal portfolio value: $${totalUSD.toFixed(2)} USD`);
  console.log(`Last updated: ${portfolio.updated_at}`);

  // Price oracle data included
  console.log(`\nPrices used:`);
  for (const [sym, price] of Object.entries(portfolio.prices)) {
    console.log(`  ${sym}: $${price}`);
  }

  return portfolio;
}

getPortfolio();

async function estimateGas(chain, to, amount, asset) {
  const res = await fetch(`${WALLET}/estimate`, {
    method: 'POST',
    headers,
    body: JSON.stringify({ chain, to, amount, asset })
  });
  return await res.json();
}

// Fee-aware transfer: pick cheapest chain for USDC transfers
async function cheapestUSDCTransfer(to, amount) {
  const evm_chains = ['ETH', 'MATIC', 'BNB', 'AVAX'];

  // Estimate fees on all EVM chains in parallel
  const estimates = await Promise.all(
    evm_chains.map(async chain => {
      const est = await estimateGas(chain, to, amount, 'USDC');
      return { chain, fee_usd: est.standard.fee_usd, ...est };
    })
  );

  // Sort by fee ascending
  estimates.sort((a, b) => a.fee_usd - b.fee_usd);

  console.log('Fee comparison for $100 USDC transfer:');
  estimates.forEach(e => {
    console.log(`  ${e.chain.padEnd(6)}: $${e.fee_usd.toFixed(4)} USD`);
  });

  const best = estimates[0];
  console.log(`\nCheapest: ${best.chain} at $${best.fee_usd.toFixed(4)} USD`);
  return best;
}

// Example output:
// Fee comparison for $100 USDC transfer:
//   MATIC : $0.0012 USD
//   BNB   : $0.0045 USD
//   AVAX  : $0.0110 USD
//   ETH   : $1.4300 USD
// Cheapest: MATIC at $0.0012 USD

async function swapAssets() {
  // Get a quote first
  const quote = await fetch(`${WALLET}/swap/quote`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      from_chain: 'ETH',
      from_asset: 'USDC',
      from_amount: 500,           // 500 USDC on ETH
      to_chain: 'SOL',
      to_asset: 'USDC',           // receive USDC on Solana
      slippage_bps: 50            // 0.5% max slippage
    })
  }).then(r => r.json());

  console.log(`From: ${quote.from_amount} USDC on ETH`);
  console.log(`To:   ${quote.to_amount} USDC on SOL`);
  console.log(`Fee:  ${quote.total_fee_usd} USD`);
  console.log(`Route: ${quote.route.join(' → ')}`);
  console.log(`ETA:  ${quote.estimated_time_seconds}s`);

  // Accept and execute the swap
  const swap = await fetch(`${WALLET}/swap/execute`, {
    method: 'POST',
    headers,
    body: JSON.stringify({ quote_id: quote.quote_id })
  }).then(r => r.json());

  console.log(`\nSwap initiated: ${swap.swap_id}`);
  console.log(`Track at: ${swap.tracker_url}`);
  return swap;
}

/**
 * portfolio-manager.js
 * Agent treasury manager: aggregate, consolidate dust, report P&L.
 * Usage: PF_API_KEY=... node portfolio-manager.js
 */
const WALLET = 'https://purpleflea.com/api/wallet';
const hdr = {
  'Authorization': `Bearer ${process.env.PF_API_KEY}`,
  'Content-Type': 'application/json'
};
const get  = url => fetch(url, { headers: hdr }).then(r => r.json());
const post = (url, body) => fetch(url, {
  method: 'POST', headers: hdr, body: JSON.stringify(body)
}).then(r => r.json());

const CONSOLIDATE_TO = 'MATIC';      // cheapest fees for USDC
const DUST_THRESHOLD_USD = 1.0;      // skip swapping tiny amounts
const MIN_NATIVE_RESERVE = 0.001;    // keep for future gas

async function manageTreasury() {
  console.log('=== Treasury Management Run ===');

  // 1. Get all balances
  const portfolio = await get(`${WALLET}/balances`);
  console.log(`Total portfolio: $${portfolio.total_usd_value.toFixed(2)}`);

  // 2. Find USDC balances above dust threshold on non-consolidation chains
  const toConsolidate = portfolio.chains.filter(c =>
    c.symbol !== CONSOLIDATE_TO &&
    c.usdc_balance > 0 &&
    c.usdc_balance * portfolio.prices['USDC'] > DUST_THRESHOLD_USD
  );

  // 3. Consolidate to MATIC for cheapest fees
  for (const chain of toConsolidate) {
    console.log(`Consolidating ${chain.usdc_balance} USDC from ${chain.symbol}...`);
    const swap = await post(`${WALLET}/swap/execute`, {
      from_chain:   chain.symbol,
      from_asset:   'USDC',
      from_amount:  chain.usdc_balance,
      to_chain:     CONSOLIDATE_TO,
      to_asset:     'USDC',
      slippage_bps: 50
    });
    console.log(`  Swap ${swap.swap_id} submitted`);
  }

  // 4. Generate report
  const report = await get(`${WALLET}/report?period=7d`);
  console.log(`\n7-day P&L: $${report.pnl_usd.toFixed(2)}`);
  console.log(`Total inflows:  $${report.inflows_usd.toFixed(2)}`);
  console.log(`Total outflows: $${report.outflows_usd.toFixed(2)}`);
  console.log(`Fees paid:      $${report.fees_paid_usd.toFixed(2)}`);
}

manageTreasury().catch(console.error);