Vote Webhooks

{
  "event": "bot_vote",
  "timestamp": "2025-11-25T10:00:00.000Z",
  "voter": {
    "userId": "987654321098765432",
    "username": "exampleuser"
  },
  "bot": {
    "id": "1234567890123456789",
    "name": "Your Bot Name"
  },
  "creditsAwarded": true,
  "adBlocker": false,
  "creditDenialReason": null
}

const crypto = require('crypto');
const express = require('express');
const Redis = require('redis');

const app = express();
app.use(express.json());

const WEBHOOK_SECRET = process.env.RANKLY_VOTE_WEBHOOK_SECRET;
const redisClient = Redis.createClient();

function verifyWebhookSignature(payload, signature, secret) {
  if (!signature || !secret) {
    return false;
  }

  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(JSON.stringify(payload))
    .digest('hex');

  try {
    return crypto.timingSafeEqual(
      Buffer.from(signature),
      Buffer.from(expectedSignature)
    );
  } catch {
    return false;
  }
}

app.post('/webhook/votes', async (req, res) => {
  const signature = req.headers['x-webhook-signature'];
  const payload = req.body;

  // Verify signature before processing
  if (!verifyWebhookSignature(payload, signature, WEBHOOK_SECRET)) {
    console.error('Webhook signature verification failed');
    return res.status(401).json({ error: 'Invalid signature' });
  }

  const { voter, bot, timestamp, creditsAwarded, adBlocker } = payload;
  const voteKey = `${voter.userId}:${timestamp}`;

  try {
    // Check for duplicates using Redis
    const isDuplicate = await redisClient.exists(voteKey);
    if (isDuplicate) {
      return res.status(200).json({ received: true, duplicate: true });
    }

    // Mark as processed
    await redisClient.setex(voteKey, 86400, '1'); // 24 hour expiry

    console.log(`Vote received: ${voter.username} (${voter.userId}) voted for ${bot.name}`);

    // Process the vote asynchronously
    await processVote({
      userId: voter.userId,
      username: voter.username,
      botId: bot.id,
      botName: bot.name,
      creditsAwarded,
      adBlocker,
      timestamp
    });

    return res.status(200).json({ received: true });
  } catch (error) {
    console.error('Error processing vote:', error);
    return res.status(500).json({ error: 'Processing failed' });
  }
});

async function processVote(data) {
  try {
    // Record the vote in your database
    await database.votes.insertOne({
      userId: data.userId,
      username: data.username,
      botId: data.botId,
      botName: data.botName,
      creditsAwarded: data.creditsAwarded,
      adBlocker: data.adBlocker,
      votedAt: new Date(data.timestamp)
    });

    // Grant rewards
    if (data.creditsAwarded && !data.adBlocker) {
      await grantVoteReward(data.userId, data.botId);
    } else if (!data.adBlocker) {
      // Still reward users for voting, even if Rankly didn't award credits
      await grantVoteReward(data.userId, data.botId);
    }

    console.log(`Processed vote from ${data.username}`);
  } catch (error) {
    console.error('Error in processVote:', error);
    throw error;
  }
}

async function grantVoteReward(userId, botId) {
  // Implement your reward logic here
  // Examples: +100 currency, +5 XP, etc.
  console.log(`Granted vote reward to ${userId}`);
}

app.listen(3000, () => {
  console.log('Vote webhook server running on port 3000');
});