Aceite pagamentos no v0 e no Bolt: Pix a R$ 0 e no ar em minutos

Quero aceitar pagamentos neste app Next.js usando a API HeroPay (referência: https://heropay.tech/llms.txt e https://docs.heropay.tech). Siga exatamente estas regras.

CONTEXTO DO PRODUTO
- O que vendo: [ex.: "Plano Pro anual do meu app de finanças"]
- Preço: [ex.: R$ 197,00]
- Parcelamento no cartão: até [12]x
- Métodos: Pix, cartão e boleto

1. VARIÁVEIS DE AMBIENTE
Use só process.env.HEROPAY_API_KEY, process.env.HEROPAY_API_URL e process.env.HEROPAY_WEBHOOK_SECRET, que já estão nas Environment Variables do projeto. Nunca crie variável com prefixo NEXT_PUBLIC_ para elas. Nunca escreva o valor da chave no código.

2. BANCO DE DADOS
Use a integração de banco do projeto (Supabase ou Neon). Crie a tabela "orders" com: id (uuid), user_id, product_key (texto), amount_cents (inteiro), status (pending, paid, refunded, canceled; padrão pending), checkout_url (texto), heropay_payment_link_id (inteiro), paid_at (timestamp nulo), created_at.
Crie "products" com product_key, name, description e price_cents, e cadastre o produto acima. O preço vive no servidor, nunca no front.

3. CRIAR O CHECKOUT: app/api/checkout/route.ts (POST)
- Arquivo só de servidor, com import "server-only" e export const runtime = "nodejs".
- Recebe apenas product_key. Nunca aceite preço vindo do cliente.
- Busca o preço em "products", cria um pedido "pending" em "orders".
- Chama POST {HEROPAY_API_URL}/payment_links com os headers:
  Authorization: Bearer {HEROPAY_API_KEY}
  Accept: application/vnd.herospark.com; version=1
  Content-Type: application/json
- Corpo:
  {
    "payment_link": {
      "name": "<nome do produto>",
      "description": "<descrição>",
      "price_cents": <centavos, inteiro, mínimo 500>,
      "absorbs_fees": true,
      "max_installments": [12],
      "payment_methods": ["pix", "credit_card", "bank_slip"],
      "src": "<id do pedido>"
    }
  }
- Salve data.id em heropay_payment_link_id e data.offer.url em checkout_url.
- Devolva ao front só checkout_url e o id do pedido. Em erro da API, responda mensagem amigável e registre o corpo do erro com console.error, sem logar a chave.

4. FRONT
- Botão "Comprar" (componente de cliente) faz fetch para /api/checkout, abre checkout_url em nova aba e leva para /pedido/[id].
- Página /pedido/[id]: mostra "Aguardando pagamento" enquanto status = pending e consulta o status a cada 5 segundos. Quando status = paid, mostra "Pagamento confirmado" e libera o acesso.
- Nunca libere acesso porque o usuário voltou do checkout. Quem libera é o status "paid" gravado pelo webhook.

5. WEBHOOK: app/api/webhooks/heropay/route.ts (POST)
- export const runtime = "nodejs". Leia o corpo bruto com await request.text() ANTES de qualquer JSON.parse.
- Calcule HMAC SHA-256 do corpo bruto com HEROPAY_WEBHOOK_SECRET (node:crypto) e compare com o header X-HeroPay-Signature usando crypto.timingSafeEqual. Confira na documentação se a assinatura vem em hex ou base64; se não estiver claro, aceite os dois e me avise. Se não bater, responda 401.
- Leia o gatilho do evento e cart.src, que é o id do pedido.
- spark_payment_confirmed: marque paid e grave paid_at só se o valor pago bater com amount_cents. Idempotente: se já está paid, responda 200 e não faça nada.
- refunded ou chargeback_request: marque refunded e revogue o acesso.
- Responda 200 rápido. cart.src desconhecido: registre no log e responda 200.
- Se o llms.txt descrever a assinatura de forma diferente, siga o llms.txt e me avise.

6. ENTREGA
Ao terminar, me mostre a URL do webhook no domínio publicado (https://<meu-app>.vercel.app/api/webhooks/heropay) e procure no projeto qualquer uso de HEROPAY_ fora de app/api e de arquivos com "server-only". A resposta certa é nenhum.

Quero aceitar pagamentos neste app usando a API HeroPay (referência: https://heropay.tech/llms.txt e https://docs.heropay.tech). Siga exatamente estas regras.

CONTEXTO DO PRODUTO
- O que vendo: [ex.: "Pacote de 100 créditos do meu app"]
- Preço: [ex.: R$ 29,90]
- Parcelamento no cartão: até [3]x
- Métodos: Pix, cartão e boleto

1. BACKEND E SEGREDOS
Todo acesso à HeroPay acontece em server functions do Bolt Cloud (se este projeto usa Supabase, em edge functions do Supabase). Leia HEROPAY_API_KEY, HEROPAY_API_URL e HEROPAY_WEBHOOK_SECRET do painel Secrets. Nunca crie variável com prefixo VITE_ ou NEXT_PUBLIC_ para elas, nunca coloque a chave em arquivo do front e nunca escreva o valor no código. Se faltar algum segredo, me peça para cadastrar em Secrets.

2. BANCO DE DADOS
Crie a tabela "orders" com: id (uuid), user_id (usuário logado), product_key (texto), amount_cents (inteiro), status (pending, paid, refunded, canceled; padrão pending), checkout_url (texto), heropay_payment_link_id (inteiro), paid_at (timestamp nulo), created_at.
Ative as regras de acesso: o usuário só lê os próprios pedidos e nunca escreve em status, amount_cents ou paid_at. Só as server functions alteram esses campos.
Crie "products" com product_key, name, description e price_cents, e cadastre o produto acima. O preço vive no servidor, nunca no front.

3. SERVER FUNCTION "create-checkout"
- Exige usuário autenticado. Recebe apenas product_key; nunca aceite preço do cliente.
- Busca o preço em "products" e cria um pedido "pending" em "orders".
- Chama POST {HEROPAY_API_URL}/payment_links com os headers:
  Authorization: Bearer {HEROPAY_API_KEY}
  Accept: application/vnd.herospark.com; version=1
  Content-Type: application/json
- Corpo:
  {
    "payment_link": {
      "name": "<nome do produto>",
      "description": "<descrição>",
      "price_cents": <centavos, inteiro, mínimo 500>,
      "absorbs_fees": true,
      "max_installments": [3],
      "payment_methods": ["pix", "credit_card", "bank_slip"],
      "src": "<id do pedido>"
    }
  }
- Salve data.id em heropay_payment_link_id e data.offer.url em checkout_url. Devolva ao front só checkout_url e o id do pedido.
- Em erro da API, devolva mensagem amigável e registre o corpo do erro no log da função, sem logar a chave.

4. FRONT
- Botão "Comprar": chama create-checkout, abre checkout_url em nova aba e leva para /pedido/:id.
- Página /pedido/:id: "Aguardando pagamento" enquanto status = pending, atualizando sozinha (tempo real do banco ou consulta a cada 5 segundos). Com status = paid, "Pagamento confirmado" e acesso liberado.
- Nunca libere acesso porque o usuário voltou do checkout. Quem libera é o status "paid" gravado pelo webhook.

5. SERVER FUNCTION "heropay-webhook"
- Pública (sem exigir login), só aceita POST.
- Leia o corpo bruto como texto ANTES de fazer parse. Calcule HMAC SHA-256 do corpo bruto com HEROPAY_WEBHOOK_SECRET e compare com o header X-HeroPay-Signature em tempo constante. Confira na documentação se a assinatura vem em hex ou base64; se não estiver claro, aceite os dois e me avise. Se não bater, responda 401.
- Leia o gatilho do evento e cart.src, que é o id do pedido.
- spark_payment_confirmed: marque paid e grave paid_at só se o valor pago bater com amount_cents. Idempotente: se já está paid, responda 200 e não faça nada.
- refunded ou chargeback_request: marque refunded e revogue o acesso.
- Responda 200 rápido. cart.src desconhecido: registre no log e responda 200.
- Se o llms.txt descrever a assinatura de forma diferente, siga o llms.txt e me avise.

6. ENTREGA
Ao terminar, me mostre a URL pública da função heropay-webhook, um comando curl para registrar o webhook na HeroPay e a lista de arquivos do front que leem alguma variável HEROPAY_. A resposta certa é nenhum. Não use a integração de Stripe do Bolt e não crie nada fora do que foi pedido.

// app/api/webhooks/heropay/route.ts
import crypto from "node:crypto";

export const runtime = "nodejs";

function assinaturaValida(corpo: string, recebida: string, segredo: string) {
  const hmac = () => crypto.createHmac("sha256", segredo).update(corpo);
  // confira o formato (hex ou base64) na documentação de webhooks e mantenha só o certo
  const esperadas = [hmac().digest("hex"), hmac().digest("base64")];
  const r = Buffer.from(recebida);
  return esperadas.some((e) => {
    const b = Buffer.from(e);
    return r.length === b.length && crypto.timingSafeEqual(r, b);
  });
}

export async function POST(request: Request) {
  const corpo = await request.text(); // corpo bruto, antes de qualquer parse
  const recebida = request.headers.get("x-heropay-signature") ?? "";
  if (!assinaturaValida(corpo, recebida, process.env.HEROPAY_WEBHOOK_SECRET!)) {
    return new Response("assinatura inválida", { status: 401 });
  }

  const evento = JSON.parse(corpo);
  const pedidoId = evento.cart?.src; // o id do pedido que você mandou em src
  // spark_payment_confirmed: marque paid só se ainda estiver pending (idempotência)
  return new Response("ok", { status: 200 });
}