Dynamic Rules

class RulesManager {
	constructor(apiKey) {
		this.apiKey = apiKey
		this.rules = null
		this.lastFetch = null
	}

	async getRules() {
		// Check if we need to fetch new rules
		if (!this.rules || this.shouldRefresh()) {
			await this.fetchRules()
		}
		return this.rules
	}

	async fetchRules() {
		const response = await fetch("https://api.ofauth.com/v2/dynamic-rules", {
			headers: { apikey: this.apiKey }
		})

		if (!response.ok) {
			throw new Error(`Failed to fetch rules: ${response.status}`)
		}

		const data = await response.json()
		this.rules = data
		this.lastFetch = Date.now()
	}

	shouldRefresh() {
		if (!this.rules || !this.lastFetch) return true
		// Refresh every 5 minutes or if rules are not current
		return Date.now() - this.lastFetch > 5 * 60 * 1000 || !this.rules.is_current
	}
}

import time
import requests

class RulesManager:
    def __init__(self, api_key):
        self.api_key = api_key
        self.rules = None
        self.last_fetch = None

    def get_rules(self):
        if not self.rules or self.should_refresh():
            self.fetch_rules()
        return self.rules

    def fetch_rules(self):
        response = requests.get(
            'https://api.ofauth.com/v2/dynamic-rules',
            headers={'apikey': self.api_key}
        )
        response.raise_for_status()

        self.rules = response.json()
        self.last_fetch = time.time()

    def should_refresh(self):
        if not self.rules or not self.last_fetch:
            return True
        
        # Refresh every 5 minutes or if rules are not current
        return (time.time() - self.last_fetch > 300 or 
                not self.rules.get('is_current', False))

class RequestSigner {
	constructor(rulesManager) {
		this.rulesManager = rulesManager
	}

	async signRequest(endpoint, userId = null) {
		const response = await fetch(
			"https://api.ofauth.com/v2/dynamic-rules/sign",
			{
				method: "POST",
				headers: {
					apikey: this.rulesManager.apiKey,
					"Content-Type": "application/json"
				},
				body: JSON.stringify({
					endpoint,
					...(userId && { "user-id": userId })
				})
			}
		)

		if (!response.ok) {
			throw new Error(`Signing failed: ${response.status}`)
		}

		return response.json()
	}

	async makeSignedRequest(endpoint, userId = null, options = {}) {
		const signedData = await this.signRequest(endpoint, userId)

		const headers = {
			...signedData.signed,
			"user-agent": "OnlyFans/1.0.0",
			accept: "application/json",
			...options.headers
		}

		return fetch(`https://onlyfans.com${endpoint}`, {
			...options,
			headers
		})
	}
}

class RequestSigner:
    def __init__(self, rules_manager):
        self.rules_manager = rules_manager

    def sign_request(self, endpoint, user_id=None):
        payload = {
            'endpoint': endpoint
        }

        if user_id:
            payload['user-id'] = user_id

        response = requests.post(
            'https://api.ofauth.com/v2/dynamic-rules/sign',
            headers={
                'apikey': self.rules_manager.api_key,
                'Content-Type': 'application/json'
            },
            json=payload
        )
        response.raise_for_status()
        return response.json()

    def make_signed_request(self, endpoint, user_id=None, **kwargs):
        signed_data = self.sign_request(endpoint, user_id)

        headers = {
            **signed_data['signed'],
            'user-agent': 'OnlyFans/1.0.0',
            'accept': 'application/json'
        }

        if 'headers' in kwargs:
            headers.update(kwargs['headers'])

        kwargs['headers'] = headers

        return requests.request(
            kwargs.get('method', 'GET'),
            f'https://onlyfans.com{endpoint}',
            **kwargs
        )

class RequestSigner {
	constructor(rulesManager) {
		this.rulesManager = rulesManager
	}

	async makeSignedRequest(endpoint, userId = null, options = {}) {
		try {
			const signedData = await this.signRequest(endpoint, userId)
			
			const headers = {
				...signedData.signed,
				"user-agent": "Mozilla ...",
				accept: "application/json",
				...options.headers
			}

			const response = await fetch(`https://onlyfans.com${endpoint}`, {
				...options,
				headers
			})

			// ONLY refresh rules on 400 error from OnlyFans
			if (response.status === 400) {
				const body = await response.json()
				if (body?.error?.code === 401 && 
					body?.error?.message?.includes("Please refresh the page")) {
					console.log("Rules outdated, fetching new rules...")
					await this.rulesManager.fetchRules()
					// Retry the request with new rules
					return this.makeSignedRequest(endpoint, userId, options)
				}
			}

			return response
		} catch (error) {
			console.error("Request failed:", error)
			throw error
		}
	}
}

class RulesManager {
	constructor(apiKey) {
		this.apiKey = apiKey
		this.rules = null
		this.lastFetchAttempt = null
		this.minRetryDelay = 5000 // 5 seconds minimum between retries
	}

	async getRules() {
		// Only fetch if we don't have rules cached
		if (!this.rules) {
			await this.fetchRules()
		}
		return this.rules
	}

	async fetchRules() {
		// Prevent too frequent retry attempts
		if (this.lastFetchAttempt && 
			Date.now() - this.lastFetchAttempt < this.minRetryDelay) {
			throw new Error("Too many fetch attempts, please wait before retrying")
		}

		this.lastFetchAttempt = Date.now()

		try {
			const response = await fetch("https://api.ofauth.com/v2/dynamic-rules", {
				headers: { apikey: this.apiKey },
				timeout: 10000 // 10 second timeout
			})

			if (!response.ok) {
				throw new Error(`Failed to fetch rules: ${response.status}`)
			}

			const data = await response.json()
			this.rules = data
			console.log("Rules fetched and cached")
		} catch (error) {
			console.error("Failed to fetch rules:", error)
			// Don't cache failed attempts, but do rate limit retries
			throw error
		}
	}

	// Force refresh when 400 error is detected
	async refreshRules() {
		console.log("Refreshing rules due to 400 error...")
		this.rules = null // Clear cache
		return this.fetchRules()
	}
}

// Set up webhook endpoint to receive rules updates
app.post('/webhook/rules-updated', (req, res) => {
	const { eventType, live, data } = req.body
	
	if (eventType === 'rules.updated') {
		console.log('Rules update webhook received:', data.revision)
		// Update cached rules directly from webhook payload
		rulesManager.updateRulesFromWebhook(data)
		res.status(200).send('OK')
	}
})

// Usage with webhook-driven updates
class WebhookRulesManager extends RulesManager {
	async getRules() {
		if (!this.rules) {
			await this.fetchRules()
		}
		return this.rules
	}
	
	// Update rules directly from webhook payload
	updateRulesFromWebhook(webhookData) {
		const { rules, revision } = webhookData
		
		// Update cached rules with the new rules from webhook
		this.rules = {
			rules,
			is_current: true,
			is_public: false, // Set based on your access level
			is_early_access: false
		}
		
		console.log(`Rules updated via webhook to revision: ${revision}`)
	}
	
	// Called by webhook handler (legacy method)
	clearCache() {
		this.rules = null
		console.log('Rules cache cleared due to webhook notification')
	}
}