Stop Burning Money on Gas.
Optimize Every Transaction

/**
 * GasOptimizer — Auto-route USDC transfers to cheapest chain
 * Uses Purple Flea Wallet API for gas estimates and transfers.
 *
 * Supported chains: ethereum, polygon, bnb, arbitrum, optimism, base, solana, tron
 */

const WALLET_API = 'https://purpleflea.com/wallet-api';

class GasOptimizer {
  constructor(agentId, apiKey) {
    this.agentId = agentId;
    this.headers = {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
    };
    // Cache gas estimates for 60 seconds to avoid rate limits
    this.cache = new Map();
    this.cacheTTL = 60_000;
  }

  /**
   * Fetch live gas costs for all supported chains via Wallet API
   * Returns array sorted cheapest-first.
   */
  async getChainGasCosts(amountUsdc = 10) {
    const cacheKey = `gas_${amountUsdc}`;
    const cached = this.cache.get(cacheKey);
    if (cached && Date.now() - cached.ts < this.cacheTTL) {
      return cached.data;
    }

    const resp = await fetch(
      `${WALLET_API}/gas-estimate?amount=${amountUsdc}&token=USDC`,
      { headers: this.headers }
    );
    const { chains } = await resp.json();

    // Sort by total cost ascending (cheapest first)
    const sorted = chains.sort((a, b) => a.estimated_cost_usd - b.estimated_cost_usd);
    this.cache.set(cacheKey, { ts: Date.now(), data: sorted });
    return sorted;
  }

  /**
   * Select the cheapest chain that satisfies the agent's constraints.
   *
   * @param {object} opts
   * @param {string[]} opts.excludeChains  - chains to skip (e.g. ['ethereum'])
   * @param {number}   opts.maxCostUsd     - reject chains above this fee threshold
   * @param {number}   opts.maxFinalitySec - reject slow-finality chains
   * @param {number}   opts.amountUsdc     - amount being transferred (for fee calc)
   */
  async selectOptimalChain({
    excludeChains = [],
    maxCostUsd = 0.10,
    maxFinalitySec = 30,
    amountUsdc = 10,
  } = {}) {
    const chains = await this.getChainGasCosts(amountUsdc);

    const candidate = chains.find(c =>
      !excludeChains.includes(c.chain) &&
      c.estimated_cost_usd <= maxCostUsd &&
      c.finality_seconds <= maxFinalitySec
    );

    if (!candidate) {
      throw new Error('No chain meets constraints — relax maxCostUsd or maxFinalitySec');
    }

    console.log(`Selected: ${candidate.chain} | fee: $${candidate.estimated_cost_usd.toFixed(5)} | finality: ${candidate.finality_seconds}s`);
    return candidate;
  }

  /**
   * Send USDC on the cheapest available chain automatically.
   */
  async sendOptimized(toAddress, amountUsdc, opts = {}) {
    const chain = await this.selectOptimalChain({ ...opts, amountUsdc });

    const resp = await fetch(`${WALLET_API}/send`, {
      method: 'POST',
      headers: this.headers,
      body: JSON.stringify({
        agent_id:  this.agentId,
        to:        toAddress,
        amount:    amountUsdc,
        token:     'USDC',
        chain:     chain.chain,
      }),
    });

    const result = await resp.json();
    return {
      ...result,
      chain_selected: chain.chain,
      gas_cost_usd:   chain.estimated_cost_usd,
    };
  }
}

// Usage example
const optimizer = new GasOptimizer(
  'agent_abc123',
  'your_api_key_here'
);

// Send 25 USDC — auto-routes to cheapest chain, never spending >$0.05 on gas
const tx = await optimizer.sendOptimized(
  '0xRecipientAddressHere',
  25,
  {
    excludeChains: ['ethereum'],  // never use expensive L1
    maxCostUsd:    0.05,           // reject if gas > $0.05
    maxFinalitySec: 10,            // need fast confirmation
  }
);
console.log(`Sent on ${tx.chain_selected}, gas: $${tx.gas_cost_usd}`);
console.log(`Tx hash: ${tx.tx_hash}`);

/**
 * BatchTransferManager — Collect transfers and execute as a single
 * multicall batch to save 60-80% on gas vs individual transactions.
 */

class BatchTransferManager {
  constructor(agentId, apiKey) {
    this.agentId = agentId;
    this.headers = { 'Authorization': `Bearer ${apiKey}` };
    this.queue   = [];
    this.maxBatch = 50;   // max transfers per batch
    this.flushAfterMs = 5000; // auto-flush every 5 seconds
    this.timer = null;
  }

  /**
   * Queue a USDC transfer. Auto-flushes when batch is full or timer fires.
   */
  enqueue(toAddress, amountUsdc, memo = '') {
    this.queue.push({ to: toAddress, amount: amountUsdc, memo });
    console.log(`Queued transfer: ${amountUsdc} USDC → ${toAddress} (queue size: ${this.queue.length})`);

    if (this.queue.length >= this.maxBatch) {
      this.flush();
      return;
    }

    // Reset debounce timer
    if (this.timer) clearTimeout(this.timer);
    this.timer = setTimeout(() => this.flush(), this.flushAfterMs);
  }

  /**
   * Execute all queued transfers as one batch transaction.
   * Cost: ~21k base gas + ~25k per transfer (vs 65k individually).
   */
  async flush(chain = 'polygon') {
    if (this.queue.length === 0) return;
    if (this.timer) { clearTimeout(this.timer); this.timer = null; }

    const transfers = [...this.queue];
    this.queue = [];

    const totalUsdc = transfers.reduce((sum, t) => sum + t.amount, 0);
    console.log(`Flushing batch: ${transfers.length} transfers, ${totalUsdc} USDC total`);

    const resp = await fetch(`${WALLET_API}/batch-send`, {
      method: 'POST',
      headers: { ...this.headers, 'Content-Type': 'application/json' },
      body: JSON.stringify({
        agent_id:  this.agentId,
        chain,
        transfers,
        token:     'USDC',
      }),
    });

    const result = await resp.json();
    const saving = (result.individual_gas_usd - result.batch_gas_usd).toFixed(4);
    console.log(`Batch tx: ${result.tx_hash}`);
    console.log(`Gas saved: $${saving} (${result.batch_gas_usd} vs $${result.individual_gas_usd})`);
    return result;
  }
}

// Usage: agent collecting payments to distribute to workers
const batcher = new BatchTransferManager('agent_xyz', 'api_key');

batcher.enqueue('0xWorker1...', 5.00, 'task-001 completion');
batcher.enqueue('0xWorker2...', 3.50, 'task-002 completion');
batcher.enqueue('0xWorker3...', 7.25, 'task-003 completion');
// All 3 flush together after 5 seconds as one tx
// Saves ~60% on gas vs 3 individual sends