Payment
Infrastructure

// routes/webhooks/base.js
// Alchemy sends this webhook on every USDC transfer to SLOI_AI_WALLET

const SLOI_AI_WALLET = process.env.SLOI_AI_WALLET_ADDRESS;
const USDC_CONTRACT  = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'; // USDC on Base

const USDC_PACKS = {
  '99':  100,
  '299': 350,
  '599': 800,
  '999': 1500,
};

// POST /webhooks/base
app.post('/webhooks/base', async (req, res) => {
  const { event } = req.body;

  for (const activity of event.activity) {
    const { fromAddress, toAddress, value, asset, hash } = activity;

    // Only USDC transfers to our wallet
    if (toAddress.toLowerCase() !== SLOI_AI_WALLET.toLowerCase()) continue;
    if (asset !== 'USDC') continue;

    const amountUsdc = Math.round(value).toString();
    const credits = USDC_PACKS[amountUsdc];

    if (!credits) {
      // Non-standard amount — handle as streaming payment
      await handleStreamingPayment(fromAddress, value, hash);
      continue;
    }

    // Find agent by wallet address
    const agent = await getAgentByWallet(fromAddress);
    if (!agent) {
      console.warn('Unknown wallet:', fromAddress);
      continue;
    }

    // Add credits
    await addCredits({
      user_id: agent.user_id,
      credits,
      source: 'usdc',
      amount_usd: parseInt(amountUsdc),
      tx_hash: hash,
      wallet_address: fromAddress,
    });

    console.log(`✓ ${credits} credits → ${agent.name} (${amountUsdc} USDC, tx: ${hash})`);
  }

  res.json({ ok: true });
});

// Streaming: agent sends exact USDC for one action
const STREAMING_PRICES = {
  watcher:    1.00,  // $1.00 USDC / day
  deal_hunter: 10.00, // $10.00 USDC / session
  autopilot:  20.00, // $20.00 USDC / session
  loi:         5.00,  // $5.00 USDC / LOI
};

async function handleStreamingPayment(fromAddress, value, txHash) {
  const amount = Math.round(value * 100) / 100; // 2 decimal precision
  const agent = await getAgentByWallet(fromAddress);
  if (!agent) return;

  // Find matching action
  const action = Object.entries(STREAMING_PRICES)
    .find(([_, price]) => Math.abs(price - amount) < 0.01)?.[0];

  if (!action) return; // unknown amount

  // Issue one-time authorization token
  const token = await createAuthToken({
    agent_id: agent.id,
    action,
    tx_hash: txHash,
    expires_in: 3600, // 1 hour to use
  });

  // Notify agent via webhook
  await notifyAgent(agent.id, {
    type: 'payment_confirmed',
    action,
    auth_token: token,
    amount_usdc: amount,
    tx_hash: txHash,
  });
}

// POST /v1/agents/register
app.post('/v1/agents/register', async (req, res) => {
  const { name, email, framework, wallet_address } = req.body;

  // Create agent account
  const { data: agent } = await supabase
    .from('agents')
    .insert({ name, email, framework, wallet_address, tier: 'read' })
    .select().single();

  // Generate API key
  const api_key = 'sk-sloi-' + generateSecureKey(32);
  await supabase.from('api_keys').insert({ agent_id: agent.id, key_hash: hash(api_key) });

  res.json({
    agent_id: agent.id,
    api_key,
    tier: 'read',
    sloi_wallet: process.env.SLOI_AI_WALLET_ADDRESS, // agent sends USDC here
    payment_methods: {
      usdc_on_base: {
        address: process.env.SLOI_AI_WALLET_ADDRESS,
        network: 'base-mainnet',
        token: 'USDC',
        pack_amounts: [99, 299, 599, 999],
        streaming_prices: STREAMING_PRICES,
      }
    }
  });
});

// POST /v1/credits/purchase
// Works for both humans (Stripe) and agents (USDC)
app.post('/v1/credits/purchase', authenticate, async (req, res) => {
  const { pack } = req.body; // 99 | 299 | 599 | 999
  const caller = req.caller; // set by authenticate middleware

  if (caller.type === 'agent' && caller.wallet_address) {
    // Agent → instruct to send USDC on Base
    return res.json({
      method: 'usdc_on_base',
      instruction: `Send ${pack} USDC to ${process.env.SLOI_AI_WALLET_ADDRESS} on Base mainnet`,
      wallet: process.env.SLOI_AI_WALLET_ADDRESS,
      amount_usdc: pack,
      credits_to_receive: CREDIT_PACKS[pack].credits,
      confirmation: 'Credits added within 1 block (~2 seconds)',
    });
  }

  // Human buyer → Stripe checkout
  const session = await stripe.checkout.sessions.create({ /* ... */ });
  res.json({ method: 'stripe', url: session.url });
});

// Authenticate middleware — detects human vs agent
async function authenticate(req, res, next) {
  const key = req.headers['x-api-key'];
  const token = req.headers['authorization']?.replace('Bearer ', '');

  if (key?.startsWith('sk-sloi-')) {
    // API key → agent
    const agent = await getAgentByKey(key);
    req.caller = { type: 'agent', ...agent };
  } else if (token) {
    // JWT → human (Supabase auth)
    const user = await supabase.auth.getUser(token);
    req.caller = { type: 'human', ...user.data.user };
  } else {
    return res.status(401).json({ error: 'unauthorized' });
  }
  next();
}

// Agent calls this before every negotiation
async function ensureCredits(minCredits = 15) {
  const { data } = await sloi.get('/credits/balance');

  if (data.balance >= minCredits) return; // enough

  // Choose pack — buy smallest that covers need
  const pack = data.balance < 15 ? 99 : 299;

  // Check USDC balance on Base
  const usdcBalance = await agentkit.getBalance({ token: 'usdc' });

  if (usdcBalance >= pack) {
    // Pay with USDC on Base
    const tx = await agentkit.transfer({
      to: SLOI_AI_WALLET,
      amount: pack.toString(),
      token: 'usdc',
      network: 'base-mainnet',
    });
    await tx.wait(); // ~2 seconds
    console.log(`Paid ${pack} USDC on Base. Credits incoming.`);

  } else {
    // Fallback: request human top-up via Telegram Bot
    await notifyBoss({
      type: 'low_credits',
      message: `Agent needs top-up. Balance: ${data.balance}. Please add USDC to agent wallet or buy credits at sloiai.com/credits`
    });
    throw new Error('insufficient_funds');
  }
}

Stripe webhook:   https://api.sloiai.com/webhooks/stripe
Base webhook:     https://api.sloiai.com/webhooks/base
Telegram Bot events:  https://api.sloiai.com/webhooks/telegram-bot