Function proxyToTelegram

worker.js:796–870

(request, info)

        else if (b.state === 'CLOSED') b.failureCount = Math.max(0, b.failureCount - 1);
    } else {
        b.failureCount++;
        b.lastFailureTime = Date.now();
        if (b.failureCount >= CIRCUIT_BREAKER.FAILURE_THRESHOLD) b.state = 'OPEN';
    }
}

function validateBotToken(token) {
    token = decodePathSegment(token);

    const cached = tokenValidationCache.get(token);
    if (cached && Date.now() < cached.expires) return cached.valid;

    if (tokenValidationCache.size >= CACHE_MAX_SIZE) {
        tokenValidationCache.delete(tokenValidationCache.keys().next().value);
    }

    let valid = false;
    if (token && token.length >= 35 && token.length <= 200 && token.includes(':')) {
        const [botId, botHash] = token.split(':');
        valid = !!(
            botId && botHash &&
            botId.length >= 5 && botHash.length >= 25 &&
            /^\d+$/.test(botId) && /^[A-Za-z0-9_-]+$/.test(botHash)
        );
    }

    tokenValidationCache.set(token, { valid, expires: Date.now() + CACHE_TTL });
    return valid;
}

async function proxyWithRetry(request, info) {
    let lastError;
    const canRetry   = !info.isFile && (request.method === 'GET' || request.method === 'HEAD');
    const maxRetries = canRetry ? RETRY_CONFIG.MAX_RETRIES : 0;

    for (let attempt = 0; attempt <= maxRetries; attempt++) {
        try {
            if (attempt > 0) {
                stats.retries++;
                const delay = Math.min(
                    RETRY_CONFIG.INITIAL_DELAY * Math.pow(RETRY_CONFIG.BACKOFF_FACTOR, attempt - 1),
                    RETRY_CONFIG.MAX_DELAY
                );
                await new Promise(r => setTimeout(r, delay));
            }

            const response = await proxyToTelegram(request, info);
            if (response.ok || response.status < 500) return response;

            lastError = new Error('HTTP ' + response.status);

        } catch (error) {
            lastError = error;
            if (error.name === 'AbortError') continue;
            if (attempt === maxRetries) throw error;
        }
    }