Add modular Roblox buyer bot and documentation

models/config.py

@@ -0,0 +1,125 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class RateConfig:
+    name: str
+    price: float
+    min: int
+    max: int
+    type: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "RateConfig":
+        return cls(
+            name=data.get("name", ""),
+            price=float(data.get("price", 0.0)),
+            min=int(data.get("min", 0)),
+            max=int(data.get("max", 0)),
+            type=data.get("type", "lifetime"),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "price": self.price,
+            "min": self.min,
+            "max": self.max,
+            "type": self.type,
+        }
+
+
+@dataclass(slots=True)
+class BotConfig:
+    shop_enabled: bool = True
+    bot_enabled: bool = True
+    min_withdraw: float = 100.0
+    treasury: float = 0.0
+    referral_percent: int = 5
+    rates: dict[str, RateConfig] = field(default_factory=dict)
+    avg_min_cookies: int = 100
+    avg_min_price: float = 2.0
+    avg_max_price: float = 20.0
+
+    @classmethod
+    def default(cls) -> "BotConfig":
+        return cls(
+            shop_enabled=True,
+            bot_enabled=True,
+            min_withdraw=100.0,
+            treasury=0.0,
+            referral_percent=5,
+            rates={
+                "lifetime_low": RateConfig(
+                    name="Lifetime 200-399 R$",
+                    price=0.33,
+                    min=200,
+                    max=399,
+                    type="lifetime",
+                ),
+                "lifetime_mid": RateConfig(
+                    name="Lifetime 400-4999 R$",
+                    price=3.10,
+                    min=400,
+                    max=4999,
+                    type="lifetime",
+                ),
+                "lifetime_high": RateConfig(
+                    name="Lifetime 5000+ R$",
+                    price=8.88,
+                    min=5000,
+                    max=10**12,
+                    type="lifetime",
+                ),
+                "year_mid": RateConfig(
+                    name="Year 1000-4999 R$",
+                    price=8.40,
+                    min=1000,
+                    max=4999,
+                    type="year",
+                ),
+                "year_high": RateConfig(
+                    name="Year 5000+ R$",
+                    price=11.11,
+                    min=5000,
+                    max=10**12,
+                    type="year",
+                ),
+            },
+            avg_min_cookies=100,
+            avg_min_price=2.0,
+            avg_max_price=20.0,
+        )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any] | None) -> "BotConfig":
+        data = data or {}
+        rates = data.get("rates") or {}
+        return cls(
+            shop_enabled=bool(data.get("shop_enabled", True)),
+            bot_enabled=bool(data.get("bot_enabled", True)),
+            min_withdraw=float(data.get("min_withdraw", 100.0)),
+            treasury=float(data.get("treasury", 0.0)),
+            referral_percent=int(data.get("referral_percent", 5)),
+            rates={
+                key: RateConfig.from_dict(value)
+                for key, value in rates.items()
+            },
+            avg_min_cookies=int(data.get("avg_min_cookies", 100)),
+            avg_min_price=float(data.get("avg_min_price", 2.0)),
+            avg_max_price=float(data.get("avg_max_price", 20.0)),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "shop_enabled": self.shop_enabled,
+            "bot_enabled": self.bot_enabled,
+            "min_withdraw": self.min_withdraw,
+            "treasury": self.treasury,
+            "referral_percent": self.referral_percent,
+            "rates": {key: value.to_dict() for key, value in self.rates.items()},
+            "avg_min_cookies": self.avg_min_cookies,
+            "avg_min_price": self.avg_min_price,
+            "avg_max_price": self.avg_max_price,
+        }

models/pricing.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class CookieDonationInfo:
+    cookie: str
+    user_id: int
+    username: str | None
+    all_time: int
+    year: int
+
+
+@dataclass(slots=True)
+class PricingResult:
+    cookie: str
+    user_id: int
+    username: str | None
+    all_time: int
+    year: int
+    price: float
+    rate_key: str | None = None
+    rate_name: str | None = None
+    donate_used: int = 0
+    is_avg: bool = False

models/responses.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class CookieValidationResult:
+    status: str
+    cookie: str | None = None
+    user_id: int | None = None
+    username: str | None = None
+    message: str | None = None

models/stats.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(slots=True)
+class BotStats:
+    total_users: int = 0
+    total_cookies: int = 0
+    total_paid_direct: float = 0.0
+    total_paid_referral: float = 0.0
+
+    @classmethod
+    def default(cls) -> "BotStats":
+        return cls()
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any] | None) -> "BotStats":
+        data = data or {}
+        return cls(
+            total_users=int(data.get("total_users", 0)),
+            total_cookies=int(data.get("total_cookies", 0)),
+            total_paid_direct=float(data.get("total_paid_direct", 0.0)),
+            total_paid_referral=float(data.get("total_paid_referral", 0.0)),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "total_users": self.total_users,
+            "total_cookies": self.total_cookies,
+            "total_paid_direct": self.total_paid_direct,
+            "total_paid_referral": self.total_paid_referral,
+        }

models/user.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class UserProfile:
+    user_id: int
+    username: str | None = None
+    registered: str = ""
+    cookies_loaded: int = 0
+    total_earned: float = 0.0
+    referral_earned: float = 0.0
+    balance: float = 0.0
+    referrer: int | None = None
+    referrals: list[int] = field(default_factory=list)
+    is_admin: bool = False
+    is_banned: bool = False
+    ban_reason: str = ""
+
+    @classmethod
+    def default(
+        cls,
+        user_id: int,
+        username: str | None = None,
+        registered: str = "",
+        referrer: int | None = None,
+        is_admin: bool = False,
+    ) -> "UserProfile":
+        return cls(
+            user_id=user_id,
+            username=username,
+            registered=registered,
+            referrer=referrer,
+            is_admin=is_admin,
+        )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "UserProfile":
+        return cls(
+            user_id=int(data.get("user_id", 0)),
+            username=data.get("username"),
+            registered=data.get("registered", ""),
+            cookies_loaded=int(data.get("cookies_loaded", 0)),
+            total_earned=float(data.get("total_earned", 0.0)),
+            referral_earned=float(data.get("referral_earned", 0.0)),
+            balance=float(data.get("balance", 0.0)),
+            referrer=data.get("referrer"),
+            referrals=[int(x) for x in data.get("referrals", [])],
+            is_admin=bool(data.get("is_admin", False)),
+            is_banned=bool(data.get("is_banned", False)),
+            ban_reason=data.get("ban_reason", ""),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "user_id": self.user_id,
+            "username": self.username,
+            "registered": self.registered,
+            "cookies_loaded": self.cookies_loaded,
+            "total_earned": self.total_earned,
+            "referral_earned": self.referral_earned,
+            "balance": self.balance,
+            "referrer": self.referrer,
+            "referrals": self.referrals,
+            "is_admin": self.is_admin,
+            "is_banned": self.is_banned,
+            "ban_reason": self.ban_reason,
+        }