index.js

'use strict';

require('dotenv').config();

const fs = require('node:fs');
const cron = require('node-cron');

/**
 * @fileoverview Automated BTC market creation bot for Worm.wtf
 * @description Creates prediction markets every 15 minutes with live BTC prices
 */

/** @constant {Object} Application configuration */
const CONFIG = Object.freeze({
    BINANCE_API_URL: 'https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT',
    WORM_API_URL: 'https://api.worm.wtf/api/market/group/',
    AUTH_TOKEN: process.env.WORM_AUTH_TOKEN,
    CRON_SCHEDULE: '*/15 * * * *',
    BODY_TEMPLATE_PATH: './body.json',
    LOGO_PATH: './assets/btc-logo.base64',
    REQUEST_TIMEOUT_MS: 10000
});

/** @constant {Object} Placeholder patterns for template replacement */
const PLACEHOLDERS = Object.freeze({
    TIME: '{{time}}',
    DATE: '{{date}}',
    PRICE: '{{price}}'
});

/**
 * Formats a numeric price into USD currency string
 * @param {number} price - Raw price value
 * @returns {string} Formatted price (e.g., "$95,432")
 */
function formatPrice(price) {
    return `$${Math.round(price).toLocaleString('en-US')}`;
}

/**
 * Calculates the next quarter-hour timestamp
 * @returns {{ time: string, date: string }} UTC time and date strings
 */
function getNextQuarterTime() {
    const nextQuarter = new Date();
    const minutesToAdd = 15 - (nextQuarter.getUTCMinutes() % 15);
    nextQuarter.setUTCMinutes(nextQuarter.getUTCMinutes() + minutesToAdd, 0, 0);

    return {
        time: nextQuarter.toLocaleTimeString('en-GB', {
            hour: '2-digit',
            minute: '2-digit',
            timeZone: 'UTC'
        }),
        date: nextQuarter.toLocaleDateString('en-GB', {
            day: 'numeric',
            month: 'long',
            year: 'numeric',
            timeZone: 'UTC'
        })
    };
}

/**
 * Replaces template placeholders with actual values
 * @param {string} text - Template text with {{placeholders}}
 * @param {{ time: string, date: string, price: string }} values - Replacement values
 * @returns {string} Processed text
 */
function applyTemplateValues(text, { time, date, price }) {
    return text
        .replaceAll(PLACEHOLDERS.TIME, time)
        .replaceAll(PLACEHOLDERS.DATE, date)
        .replaceAll(PLACEHOLDERS.PRICE, price);
}

/**
 * Updates all template fields in market body data
 * @param {Object} bodyData - Market body template
 * @param {{ time: string, date: string, price: string }} values - Values to apply
 * @returns {Object} Updated body data
 */
function updateMarketBody(bodyData, values) {
    const apply = (text) => applyTemplateValues(text, values);

    const updated = { ...bodyData };
    updated.title = apply(updated.title);
    updated.description = apply(updated.description);

    if (updated.markets?.[0]) {
        const market = { ...updated.markets[0] };
        market.title = apply(market.title);
        market.description = apply(market.description);
        market.rules = market.rules?.map(apply);
        updated.markets = [market, ...updated.markets.slice(1)];
    }

    return updated;
}

/**
 * Fetches current BTC price from Binance API
 * @returns {Promise<number>} Current BTC price in USD
 * @throws {Error} If API request fails
 */
async function fetchBTCPrice() {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), CONFIG.REQUEST_TIMEOUT_MS);

    try {
        const response = await fetch(CONFIG.BINANCE_API_URL, { signal: controller.signal });

        if (!response.ok) {
            throw new Error(`Binance API error: ${response.status}`);
        }

        const data = await response.json();
        return parseFloat(data.price);
    } finally {
        clearTimeout(timeoutId);
    }
}

/**
 * Sends market creation request to Worm API
 * @param {Object} bodyData - Market creation payload
 * @returns {Promise<Object>} API response
 * @throws {Error} If API request fails
 */
async function submitMarket(bodyData) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), CONFIG.REQUEST_TIMEOUT_MS);

    try {
        const response = await fetch(CONFIG.WORM_API_URL, {
            method: 'POST',
            signal: controller.signal,
            headers: {
                'Accept': 'application/json',
                'Authorization': CONFIG.AUTH_TOKEN,
                'Content-Type': 'application/json',
                'Referer': 'https://www.worm.wtf/'
            },
            body: JSON.stringify(bodyData)
        });

        if (!response.ok) {
            throw new Error(`Worm API error: ${response.status}`);
        }

        return response.json();
    } finally {
        clearTimeout(timeoutId);
    }
}

/**
 * Reads and parses the market body template file
 * Loads logo from separate file for cleaner organization
 * @returns {Object} Parsed template data with logo
 * @throws {Error} If file read or parse fails
 */
function loadBodyTemplate() {
    const rawData = fs.readFileSync(CONFIG.BODY_TEMPLATE_PATH, 'utf8');
    const template = JSON.parse(rawData);

    // Load logo from separate file
    const logo = fs.readFileSync(CONFIG.LOGO_PATH, 'utf8').trim();
    template.logo = logo;

    return template;
}

/**
 * Main market creation workflow
 * @returns {Promise<void>}
 */
async function createMarket() {
    const timestamp = new Date().toISOString();

    try {
        console.log(`\n[${timestamp}] Starting market creation...`);

        const btcPrice = await fetchBTCPrice();
        const formattedPrice = formatPrice(btcPrice);
        const { time, date } = getNextQuarterTime();

        console.log(`  → BTC Price: ${formattedPrice}`);
        console.log(`  → Target: ${time} UTC (${date})`);

        const template = loadBodyTemplate();
        const marketData = updateMarketBody(template, { time, date, price: formattedPrice });
        const result = await submitMarket(marketData);

        console.log(`  → API Response:`, JSON.stringify(result, null, 2));
        console.log(`[${timestamp}] ✓ Market created successfully\n`);

    } catch (error) {
        console.error(`[${timestamp}] ✗ Market creation failed: ${error.message}`);

        if (error.name === 'AbortError') {
            console.error('  → Request timed out');
        }
    }
}

/** Handles graceful shutdown */
function handleShutdown(signal) {
    console.log(`\n[${new Date().toISOString()}] Received ${signal}, shutting down...`);
    process.exit(0);
}

// Register shutdown handlers
process.on('SIGINT', () => handleShutdown('SIGINT'));
process.on('SIGTERM', () => handleShutdown('SIGTERM'));

// Initialize scheduler
const scheduledTask = cron.schedule(CONFIG.CRON_SCHEDULE, createMarket);

console.log('═══════════════════════════════════════════════');
console.log('  🤖 Worm Market Bot - Started');
console.log('═══════════════════════════════════════════════');
console.log(`  Schedule: Every 15 minutes`);
console.log(`  Template: ${CONFIG.BODY_TEMPLATE_PATH}`);
console.log('  Press Ctrl+C to stop');
console.log('═══════════════════════════════════════════════\n');