Documentação da API

{
  "saldo": 412.3,
  "plano": { "id": "pro", "nome": "Pro", "desconto": 36 },
  "margem_revenda": 100
}

{ "erro": { "codigo": "saldo_insuficiente", "mensagem": "Saldo insuficiente: esta conta custa R$ 160,58. Recarregue no PIX." } }

const BASE = "https://quantumresell.lovable.app/api/v1";
const KEY = process.env.QUANTUMRESELL_KEY; // nunca no navegador

async function api(path, init = {}) {
  const res = await fetch(BASE + path, {
    ...init,
    headers: { Authorization: `Bearer ${KEY}`, "Content-Type": "application/json", ...init.headers },
  });
  const body = await res.json();
  if (!res.ok) throw Object.assign(new Error(body.erro.mensagem), { codigo: body.erro.codigo });
  return body;
}

// 1) a conta mais barata de Valorant BR com faca, até R$ 150 para você
const { contas } = await api("/contas?jogo=valorant&faca=true&preco_max=150&ordem=menor_preco");
const conta = contas[0];

// 2) compra com proteção de preço e de repetição
let pedido = await api("/pedidos", {
  method: "POST",
  headers: { "Idempotency-Key": "venda-" + Date.now() },
  body: JSON.stringify({ jogo: "valorant", conta: conta.id, preco_maximo: conta.precos.revendedor }),
});

// 3) se ainda estiver comprando, espera
while (pedido.status === "comprando") {
  await new Promise((r) => setTimeout(r, 5000));
  pedido = await api(`/pedidos/${pedido.id}`);
}

if (pedido.status === "entregue") console.log(pedido.entrega); // envie ao seu cliente
else console.log("Não entregue:", pedido.status, pedido.mensagem);

// bot.js — discord.js v14. Variáveis: QUANTUMRESELL_KEY, DISCORD_TOKEN, DISCORD_APP_ID
import { Client, GatewayIntentBits, PermissionFlagsBits, REST, Routes, SlashCommandBuilder } from "discord.js";

const API = "https://quantumresell.lovable.app/api/v1";
async function api(path, init = {}) {
  const r = await fetch(API + path, {
    ...init,
    headers: {
      Authorization: `Bearer ${process.env.QUANTUMRESELL_KEY}`,
      "Content-Type": "application/json",
      ...init.headers,
    },
  });
  const body = await r.json();
  if (!r.ok) throw new Error(body.erro?.mensagem ?? "Erro na API");
  return body;
}

const commands = [
  new SlashCommandBuilder().setName("contas").setDescription("Contas à venda")
    .addStringOption((o) => o.setName("jogo").setDescription("valorant, fortnite…").setRequired(true)),
  // /comprar gasta o SEU saldo: só administradores. Numa loja de verdade, o bot só compra
  // depois que o cliente pagou (no seu sistema de pagamento).
  new SlashCommandBuilder().setName("comprar").setDescription("Compra uma conta e entrega na DM")
    .setDefaultMemberPermissions(PermissionFlagsBits.Administrator)
    .addStringOption((o) => o.setName("jogo").setDescription("valorant, fortnite…").setRequired(true))
    .addStringOption((o) => o.setName("id").setDescription("id da conta").setRequired(true))
    .addUserOption((o) => o.setName("cliente").setDescription("quem recebe").setRequired(true)),
].map((c) => c.toJSON());

await new REST().setToken(process.env.DISCORD_TOKEN)
  .put(Routes.applicationCommands(process.env.DISCORD_APP_ID), { body: commands });

const client = new Client({ intents: [GatewayIntentBits.Guilds] });

client.on("interactionCreate", async (i) => {
  if (!i.isChatInputCommand()) return;
  try {
    if (i.commandName === "contas") {
      const jogo = i.options.getString("jogo");
      const { contas } = await api(`/contas?jogo=${jogo}&ordem=menor_preco`);
      const lista = contas.slice(0, 10)
        .map((c) => `\`${c.id}\` ${c.titulo} — R$ ${c.precos.sugerido}`)
        .join("\n");
      return i.reply({ content: lista || "Nenhuma conta agora.", ephemeral: true });
    }
    if (i.commandName === "comprar") {
      await i.deferReply({ ephemeral: true });
      const pedido = await api("/pedidos", {
        method: "POST",
        headers: { "Idempotency-Key": `discord-${i.id}` }, // o mesmo comando nunca compra duas vezes
        body: JSON.stringify({ jogo: i.options.getString("jogo"), conta: i.options.getString("id") }),
      });
      if (pedido.status !== "entregue") return i.editReply(`Pedido ${pedido.id}: ${pedido.status}`);
      const e = pedido.entrega;
      await i.options.getUser("cliente").send(
        `Sua conta chegou! Pedido ${pedido.id}\nLogin: ${e.login}\nSenha: ${e.senha}` +
          (e.email ? `\nE-mail: ${e.email}\nSenha do e-mail: ${e.senha_email}` : ""),
      );
      return i.editReply("Entregue na DM do cliente.");
    }
  } catch (err) {
    return i.deferred ? i.editReply(err.message) : i.reply({ content: err.message, ephemeral: true });
  }
});

client.login(process.env.DISCORD_TOKEN);

// app/api/entregar/route.ts — no SERVIDOR da sua loja (Next.js). Chame depois que o
// seu sistema de pagamento confirmar que o cliente pagou.
export async function POST(req: Request) {
  const { vendaId, jogo, conta, precoQueVoceViu } = await req.json();

  const r = await fetch("https://quantumresell.lovable.app/api/v1/pedidos", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QUANTUMRESELL_KEY}`,
      "Content-Type": "application/json",
      "Idempotency-Key": `venda-${vendaId}`, // pagamento confirmado duas vezes = uma compra só
    },
    body: JSON.stringify({ jogo, conta, preco_maximo: precoQueVoceViu }),
  });
  const pedido = await r.json();
  if (!r.ok) {
    // ex.: conta_indisponivel → ofereça outra conta ou devolva o pagamento do cliente
    return Response.json({ erro: pedido.erro.codigo, mensagem: pedido.erro.mensagem }, { status: 409 });
  }

  // salve pedido.id na venda. Se ainda estiver "comprando", o webhook pedido.entregue avisa.
  return Response.json({ status: pedido.status, entrega: pedido.entrega });
}

{
  "id": "evt_8Qm2fV7xKp1sZt4LbN0cRw9e",
  "tipo": "pedido.entregue",
  "criado_em": "2026-11-13T20:00:03.000Z",
  "dados": {
    "pedido": {
      "id": "AB12CD34",
      "status": "entregue",
      "jogo": "valorant",
      "valor_pago": 160.58,
      "…": "os mesmos campos de GET /pedidos/{id}",
      "entrega": { "login": "raze.main93", "senha": "••••••••", "email": "conta@outlook.com" }
    }
  }
}

import crypto from "node:crypto";
import express from "express";

const SEGREDO = process.env.QUANTUMRESELL_WEBHOOK_SECRET; // whsec_…
const app = express();

app.post("/webhooks/quantumresell", express.raw({ type: "application/json" }), (req, res) => {
  const corpo = req.body.toString("utf8");
  const partes = Object.fromEntries(
    String(req.get("X-QuantumResell-Assinatura")).split(",").map((p) => p.split("=")),
  );
  const esperado = crypto.createHmac("sha256", SEGREDO).update(`${partes.t}.${corpo}`).digest("hex");
  const recente = Math.abs(Date.now() / 1000 - Number(partes.t)) < 300;
  const igual =
    partes.v1?.length === esperado.length &&
    crypto.timingSafeEqual(Buffer.from(partes.v1), Buffer.from(esperado));
  if (!recente || !igual) return res.status(400).send("assinatura inválida");

  const evento = JSON.parse(corpo);
  res.sendStatus(200); // responda logo; processe depois

  if (evento.tipo === "pedido.entregue") {
    // já processou este evento.id? ignore. Se não, envie evento.dados.pedido.entrega ao cliente
  }
});