Upload folder using huggingface_hub (#1)

- Upload folder using huggingface_hub (8cdbae16faff85fffba37495fe3b42c5176e2b69)

.env

@@ -0,0 +1,15 @@
+
+API_ID=25514329
+API_HASH=2b15eb2dd52e935d6b091432b71cfc78
+
+TAPS_ENABLED=True
+TAPS_PER_SECOND=[20, 30]
+PVP_ENABLED=False
+PVP_LEAGUE=
+PVP_STRATEGY=aggressive
+PVP_COUNT=10
+SLEEP_BETWEEN_START=
+ERRORS_BEFORE_STOP=
+USE_PROXY_FROM_FILE=
+REF_ID=hero5413217144
+MONEY_TO_SAVE=100

.env-example

@@ -0,0 +1,13 @@
+API_ID=
+API_HASH=
+
+TAPS_ENABLED=
+TAPS_PER_SECOND=
+PVP_ENABLED=
+PVP_LEAGUE=
+PVP_STRATEGY=
+PVP_COUNT=
+SLEEP_BETWEEN_START=
+ERRORS_BEFORE_STOP=
+USE_PROXY_FROM_FILE=
+REF_ID=

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.10
+
+WORKDIR /app
+
+COPY requirements.txt requirements.txt
+
+RUN pip3 install --upgrade pip setuptools wheel
+RUN pip3 install --no-warn-script-location --no-cache-dir -r requirements.txt
+
+COPY . .
+
+ENTRYPOINT ["python3", "main.py"]
+CMD ["-a", "2"]

INSTALL.bat

@@ -0,0 +1,11 @@
+@echo off
+echo Creating virtual environment...
+python -m venv venv
+echo Activating virtual environment...
+call venv\Scripts\activate
+echo Installing dependencies...
+pip install -r requirements.txt
+echo Copying .env-example to .env...
+copy .env-example .env
+echo Please edit the .env file to add your API_ID and API_HASH.
+pause

INSTALL.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+install_python() {
+    echo "Select the Python version to install:"
+    echo "1) Python 3.10"
+    echo "2) Python 3.11"
+    echo "3) Python 3.12"
+    read -p "Enter the number of your choice: " choice
+
+    case $choice in
+        1) version="3.10" ;;
+        2) version="3.11" ;;
+        3) version="3.12" ;;
+        *) echo "Invalid choice"; exit 1 ;;
+    esac
+
+    if command -v apt-get &> /dev/null; then
+        sudo apt-get update
+        sudo apt-get install -y python$version python$version-venv python$version-pip
+    elif command -v yum &> /dev/null; then
+        sudo yum install -y https://repo.ius.io/ius-release-el$(rpm -E %{rhel}).rpm
+        sudo yum install -y python$version python$version-venv python$version-pip
+    elif command -v dnf &> /dev/null; then
+        sudo dnf install -y python$version python$version-venv python$version-pip
+    else
+        echo "Package manager not supported. Please install Python manually."
+        exit 1
+    fi
+}
+
+if ! command -v python3 &> /dev/null; then
+    install_python
+fi
+
+echo "Creating virtual environment..."
+python3 -m venv venv
+
+echo "Activating virtual environment..."
+source venv/bin/activate
+
+echo "Installing dependencies..."
+pip install -r requirements.txt
+
+echo "Copying .env-example to .env..."
+cp .env-example .env
+
+echo "Please edit the .env file to add your API_ID and API_HASH."
+read -p "Press any key to continue..."

START.bat

@@ -0,0 +1,9 @@
+@echo off
+echo Activating virtual environment...
+title MuskEmpire
+call venv\Scripts\activate
+echo Starting git pull
+git pull
+echo Starting the bot...
+python main.py -a 2
+pause

START.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+echo "Activating virtual environment..."
+source venv/bin/activate
+
+echo "Starting the bot..."
+python main.py
+
+echo "Press any key to continue..."
+read -n 1 -s

bot/config/headers.py

@@ -0,0 +1,12 @@
+headers = {
+    "Accept": "*/*",
+    "Accept-Language": "ru,ru-RU;q=0.9,en-US;q=0.8,en;q=0.7",
+    "Content-Type": "application/json",
+    "Origin": "https://game.xempire.io",
+    "Referer": "https://game.xempire.io/",
+    "Sec-Fetch-Dest": "empty",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Site": "same-site",
+    "User-Agent": "Mozilla/5.0 (Linux; Android 9; SM-N971N Build/PQ3B.190801.07101020; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/124.0.6367.82 Safari/537.36",
+    "X-Requested-With": "org.telegram.messenger.web",
+}

bot/config/logger.py

@@ -0,0 +1,15 @@
+import sys
+
+from loguru import logger
+
+logger.remove()
+
+logger_str_format = (
+    "<white>{time:YYYY-MM-DD HH:mm:ss}</white> | "
+    "<level>{level: <8}</level> | "
+    "<c><b>{line: <5}</b></c>| "
+    "<c><b>{extra[session_name]: <7}</b></c> | "
+    "<white><b>{message}</b></white>"
+)
+logger.add(sink=sys.stdout, format=logger_str_format, colorize=True)
+log = logger.bind(session_name="GLOBAL").opt(colors=True)

bot/config/settings.py

@@ -0,0 +1,79 @@
+from enum import Enum
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+logo = """
+
+███    ███ ██    ██ ███████ ██   ██     ███████ ███    ███ ██████  ██ ██████  ███████
+████  ████ ██    ██ ██      ██  ██      ██      ████  ████ ██   ██ ██ ██   ██ ██
+██ ████ ██ ██    ██ ███████ █████       █████   ██ ████ ██ ██████  ██ ██████  █████
+██  ██  ██ ██    ██      ██ ██  ██      ██      ██  ██  ██ ██      ██ ██   ██ ██
+██      ██  ██████  ███████ ██   ██     ███████ ██      ██ ██      ██ ██   ██ ███████
+
+"""
+
+
+class Strategy(str, Enum):
+    flexible = "flexible"
+    protective = "protective"
+    aggressive = "aggressive"
+    random = "random"
+
+
+class League(str, Enum):
+    bronze = "bronze"
+    silver = "silver"
+    gold = "gold"
+    platina = "platina"
+    diamond = "diamond"
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_ignore_empty=True, extra="allow")
+
+    API_ID: int
+    API_HASH: str
+
+    LOGIN_TIMEOUT: int = 3600
+
+    TAPS_ENABLED: bool = True
+    TAPS_PER_SECOND: list[int] = [20, 30]
+    AUTO_UPGRADE_HERO: bool = True
+    PVP_ENABLED: bool = True
+    PVP_LEAGUE: League = League.bronze
+    PVP_STRATEGY: Strategy = Strategy.random
+    PVP_COUNT: int = 5
+
+    SLEEP_BETWEEN_START: list[int] = [10, 20]
+    SESSION_AC_DELAY: int = 10
+    ERRORS_BEFORE_STOP: int = 5
+    USE_PROXY_FROM_FILE: bool = False
+    ADD_LOCAL_MACHINE_AS_IP: bool = False
+
+    RANDOM_SLEEP_TIME: int = 8
+    SKILL_WEIGHT: float = 0
+    MAX_SKILL_UPGRADE_COSTS: int = 5e9
+
+    MONEY_TO_SAVE: int = 1_000_000
+
+    AUTO_UPGRADE_MINING: bool = True
+    MAX_MINING_UPGRADE_LEVEL: int = 30
+    MAX_MINING_ENERGY_RECOVERY_UPGRADE_LEVEL: int = 60
+    MINING_ENERGY_SKILLS: list[str] = ["energy_capacity", "energy_recovery", "profit_per_tap_power"]
+    MAX_MINING_UPGRADE_COSTS: int = 5_000_000
+
+    SKIP_IMPROVE_DISCIPLINE_BUG: bool = Field(
+        default=False,
+        description="Skip improve discipline bug for eror "
+        "{'success': False, 'error': 'invalid key improve_discipline'}",
+    )
+    SKIP_TO_UPGRADE_SKILLS: list = Field([], description='Skip upgrade skills. For example: ["Уборщик", "Рекрутер,HR"]')
+
+    BOT_SLEEP_TIME: list[int] = [3000, 3500]
+    REF_ID: str = "hero1092379081"
+    base_url: str = "https://game.muskempire.io/"
+    bot_name: str = "empirebot"
+
+
+config = Settings()

bot/core/api.py

@@ -0,0 +1,320 @@
+import asyncio
+import json
+import random
+from datetime import datetime
+from typing import NamedTuple
+from urllib.parse import parse_qs
+
+import aiohttp
+from aiocache import Cache, cached
+from better_proxy import Proxy
+from pyrogram import Client, errors
+from pyrogram.errors import FloodWait, RPCError, UserAlreadyParticipant
+from pyrogram.raw.functions import account
+from pyrogram.raw.functions.messages import RequestAppWebView
+from pyrogram.raw.types import InputBotAppShortName, InputNotifyPeer, InputPeerNotifySettings
+from pytz import UTC
+
+from bot.config.logger import log
+from bot.config.settings import config
+from bot.helper.utils import error_handler, handle_request
+
+from .errors import TapsError
+from .models import FundHelper, Profile, PvpData, UserDataAfter
+from .utils import num_prettier
+
+
+class TgWebData(NamedTuple):
+    hash: str
+    request_data: dict
+
+
+class CryptoBotApi:
+    def __init__(self, tg_client: Client):
+        self.session_name = tg_client.name
+        self.tg_client = tg_client
+        self.user_id = None
+        self.api_url = "https://api.xempire.io"
+        self.need_quiz = False
+        self.need_rebus = False
+        self.rebus_key = ""
+        self.errors = 0
+        self.logger = log.bind(session_name=self.session_name)
+        self._peer = None
+
+    async def get_tg_web_data(self, proxy: str | None) -> TgWebData:
+        if proxy:
+            proxy = Proxy.from_str(proxy)
+            proxy_dict = {
+                "scheme": proxy.protocol,
+                "hostname": proxy.host,
+                "port": proxy.port,
+                "username": proxy.login,
+                "password": proxy.password,
+            }
+        else:
+            proxy_dict = None
+
+        self.tg_client.proxy = proxy_dict
+
+        try:
+            async with self.tg_client:
+                if not self._peer:
+                    try:
+                        self._peer = await self.tg_client.resolve_peer(config.bot_name)
+                    except FloodWait as error:
+                        self.logger.warning(f"FloodWait error: {error} | Retry in {error.value} seconds")
+                        await asyncio.sleep(delay=error.value)
+                        # update in session db peer ids to fix this errors˚
+                        async for dialog in self.tg_client.get_dialogs():
+                            if dialog.chat and dialog.chat.username and dialog.chat.username == config.bot_name:
+                                break
+                        self._peer = await self.tg_client.resolve_peer(config.bot_name)
+
+                web_view = await self.tg_client.invoke(
+                    RequestAppWebView(
+                        peer=self._peer,
+                        app=InputBotAppShortName(bot_id=self._peer, short_name="game"),
+                        platform="android",
+                        write_allowed=True,
+                        start_param=config.REF_ID,
+                    )
+                )
+                tg_web_data = parse_qs(web_view.url.split("#")[1]).get("tgWebAppData")[0]
+                query_params = parse_qs(tg_web_data)
+            return TgWebData(
+                request_data={
+                    "data": {
+                        "chatId": "",
+                        "chatInstance": tg_web_data,
+                        "chatType": query_params.get("chat_type")[0],
+                        "initData": tg_web_data,
+                        "platform": "android",
+                        "startParam": config.REF_ID,
+                    },
+                },
+                hash=query_params.get("hash")[0],
+            )
+
+        except RuntimeError as error:
+            raise error from error
+        except FloodWait as error:
+            log.warning(f"{self.session_name} | FloodWait error: {error} | Retry in {error.value} seconds")
+            await asyncio.sleep(delay=error.value)
+            raise
+        except Exception as error:
+            log.error(f"{self.session_name} | Authorization error: {error}")
+            await asyncio.sleep(delay=3)
+            raise
+
+    async def join_and_archive_channel(self, channel_name: str) -> None:
+        try:
+            async with self.tg_client:
+                try:
+                    chat = await self.tg_client.join_chat(channel_name)
+                    self.logger.info(f"Successfully joined to  <g>{chat.title}</g>")
+                except UserAlreadyParticipant:
+                    self.logger.info(f"Chat <y>{channel_name}</y> already joined")
+                    chat = await self.tg_client.get_chat(channel_name)
+                except RPCError:
+                    self.logger.error(f"Channel <y>{channel_name}</y> not found")
+                    raise
+
+                await self.sleeper()
+                peer = await self.tg_client.resolve_peer(chat.id)
+
+                await self.tg_client.invoke(
+                    account.UpdateNotifySettings(
+                        peer=InputNotifyPeer(peer=peer), settings=InputPeerNotifySettings(mute_until=2147483647)
+                    )
+                )
+                self.logger.info(f"Successfully muted chat <g>{chat.title}</g> for channel <y>{channel_name}</y>")
+                await self.sleeper()
+                await self.tg_client.archive_chats(chat_ids=[chat.id])
+                self.logger.info(f"Channel <g>{chat.title}</g> successfully archived for channel <y>{channel_name}</y>")
+
+        except errors.FloodWait as e:
+            self.logger.error(f"Waiting {e.value} seconds before the next attempt.")
+            await asyncio.sleep(e.value)
+            raise
+
+    async def sleeper(self, delay: int = config.RANDOM_SLEEP_TIME, additional_delay: int = 4) -> None:
+        await asyncio.sleep(random.random() * delay + additional_delay)
+
+    @error_handler()
+    @handle_request("/telegram/auth")
+    async def login(self, *, response_json: dict, json_body: dict) -> bool:
+        if response_json.get("success", False):
+            self.logger.success("Login successful")
+            return True
+        return False
+
+    @error_handler()
+    @handle_request("/dbs", json_body={"data": {"dbs": ["all"]}})
+    async def get_dbs(self, *, response_json: dict) -> dict:
+        return response_json["data"]
+
+    @error_handler()
+    @handle_request("/hero/balance/sync", json_body={"data": {}})
+    async def syn_hero_balance(self, *, response_json: dict) -> Profile:
+        self._update_money_balance(response_json)
+        self.logger.info(
+            f"Level: <blue>{self.level}</blue> | "
+            f"Balance: <y>{num_prettier(self.balance)}</y> | "
+            f"Money per hour: <g>{num_prettier(self.mph)}</g>"
+        )
+        return Profile(**response_json["data"])
+
+    @error_handler()
+    @handle_request("/user/data/all", json_body={"data": {}})
+    async def get_profile_full(self, *, response_json: dict) -> dict:
+        return dict(**response_json["data"])
+
+    @error_handler()
+    @handle_request("/user/data/after", json_body={"data": {"lang": "en"}})
+    async def user_data_after(self, *, response_json: dict) -> UserDataAfter:
+        return UserDataAfter(**response_json["data"])
+
+    @error_handler()
+    @handle_request("/hero/bonus/offline/claim")
+    async def get_offline_bonus(self, *, response_json: dict) -> None:
+        self._update_money_balance(response_json)
+        self.logger.success(f"Offline bonus claimed: <y>+{num_prettier(self.user_profile.offline_bonus)}</y>")
+
+    @error_handler()
+    @handle_request("/quests/daily/claim")
+    async def daily_reward(self, *, response_json: dict, json_body: dict) -> None:
+        self._update_money_balance(response_json)
+
+    @error_handler()
+    @handle_request("/quests/claim")
+    async def quest_reward_claim(self, *, response_json: dict, json_body: dict) -> bool:
+        self._update_money_balance(response_json)
+        return True
+
+    @error_handler()
+    @handle_request("/quests/daily/progress/claim")
+    async def daily_quest_reward(self, *, response_json: dict, json_body: dict) -> None:
+        self._update_money_balance(response_json)
+
+    @error_handler()
+    @handle_request("/quests/daily/progress/all")
+    async def all_daily_quests(self, *, response_json: dict) -> dict:
+        return response_json["data"]
+
+    @error_handler()
+    @handle_request("/quests/check")
+    async def quest_check(self, *, response_json: dict, json_body: dict) -> bool:
+        await self.sleeper()
+        await self.quest_reward_claim(json_body=json_body)
+
+    @error_handler()
+    @handle_request("/friends/claim")
+    async def friend_reward(self, *, response_json: dict, json_body: dict) -> None:
+        self._update_money_balance(response_json)
+
+    @error_handler()
+    @handle_request("/hero/action/tap")
+    async def api_perform_taps(self, *, response_json: dict, json_body: dict) -> int:
+        if (error_msg := response_json.get("error")) and "take some rest" in error_msg:
+            raise TapsError(error_msg)
+        data = self._update_money_balance(response_json)
+        self.tapped_today = data.get("tappedToday", 0)
+        return int(data["hero"]["earns"]["task"]["energy"])
+
+    @cached(ttl=2 * 60 * 60, cache=Cache.MEMORY)
+    @error_handler()
+    @handle_request(
+        "https://raw.githubusercontent.com/testingstrategy/musk_daily/main/daily.json",
+        method="GET",
+        full_url=True,
+    )
+    async def get_helper(self, *, response_json: str) -> FundHelper | dict:
+        response_json = json.loads(response_json)
+        return FundHelper(
+            funds=response_json.get(str(datetime.now(UTC).date()), {}).get("funds", set()),
+            **response_json,
+        )
+
+    @error_handler()
+    @handle_request("/fund/info")
+    async def get_funds_info(self, *, response_json: dict) -> dict:
+        return response_json["data"]
+
+    @error_handler()
+    @handle_request("/box/list", json_body={})
+    async def get_box_list(self, *, response_json: dict) -> dict:
+        return response_json["data"] or {}
+
+    @error_handler()
+    @handle_request("/box/open")
+    async def box_open(self, *, response_json: dict, json_body: dict) -> list:
+        return response_json["data"]
+
+    @error_handler()
+    @handle_request("/pvp/info")
+    async def get_pvp_info(self, *, response_json: dict) -> dict:
+        return response_json["data"]
+
+    @error_handler()
+    @handle_request("/pvp/fight/start")
+    async def get_pvp_fight(self, *, response_json: dict, json_body: dict) -> PvpData | None:
+        if response_json["data"].get("opponent"):
+            return PvpData(**response_json["data"])
+        return None
+
+    @error_handler()
+    @handle_request("/pvp/claim")
+    async def get_pvp_claim(self, *, response_json: dict) -> None:
+        if response_json.get("success"):
+            self._update_money_balance(response_json)
+
+    @error_handler()
+    @handle_request(
+        "/settings/save",
+        json_body={
+            "data": {
+                "id": None,
+                "music": False,
+                "sound": True,
+                "vibrate": True,
+                "animations": True,
+                "darkTheme": True,
+                "lang": "en",
+            }
+        },
+    )
+    async def sent_eng_settings(self, *, response_json: dict) -> None: ...
+
+    @error_handler()
+    @handle_request("/fund/invest")
+    async def invest(self, *, response_json: dict, json_body: dict) -> None:
+        data = self._update_money_balance(response_json)
+        for fnd in data["funds"]:
+            if fnd["fundKey"] == json_body["data"]["fund"]:
+                money = fnd["moneyProfit"]
+                money_str = (
+                    f"Win: <y>+{num_prettier(money)}</y>" if money > 0 else f"Loss: <red>{num_prettier(money)}</red>"
+                )
+                self.logger.success(f"Invest completed: {money_str}")
+                break
+
+    @error_handler()
+    @handle_request("/skills/improve")
+    async def skills_improve(self, *, response_json: dict, json_body: dict) -> None:
+        self._update_money_balance(response_json)
+
+    async def check_proxy(self, proxy: Proxy) -> None:
+        try:
+            response = await self.http_client.get(url="https://httpbin.org/ip", timeout=aiohttp.ClientTimeout(10))
+            ip = (await response.json()).get("origin")
+            self.logger.info(f"Proxy IP: {ip}")
+        except Exception:
+            self.logger.exception(f"Proxy: {proxy}")
+
+    def _update_money_balance(self, response_json: dict) -> dict:
+        response_json = response_json["data"]
+        self.balance = int(response_json["hero"]["money"])
+        self.level = int(response_json["hero"]["level"])
+        self.mph = int(response_json["hero"]["moneyPerHour"])
+        return response_json

bot/core/api_js_helpers/bet_counter.py

@@ -0,0 +1,48 @@
+class BetCounter:
+    bet_steps_count = 7
+
+    def __init__(self, obj):
+        self.obj = obj
+
+    def min_bet(self):
+        multiplier = 2
+        if self.obj.level < 3:
+            multiplier = 5
+        elif self.obj.level < 6:
+            multiplier = 4
+        elif self.obj.level < 10:
+            multiplier = 3
+
+        calculated_bet = self.smart_zero_round(self.obj.mph * multiplier / (self.bet_steps_count * 3))
+        return calculated_bet or 100
+
+    def max_bet(self):
+        return self.min_bet() * self.bet_steps_count
+
+    def smart_zero_round(self, amount: int):
+        def round_to_nearest(value, base=100):
+            return round(value / base) * base
+
+        if amount < 100:
+            return round_to_nearest(amount, 50)
+        elif amount < 1000:
+            return round_to_nearest(amount, 100)
+        elif amount < 10000:
+            return round_to_nearest(amount, 1000)
+        elif amount < 100000:
+            return round_to_nearest(amount, 10000)
+        elif amount < 1000000:
+            return round_to_nearest(amount, 100000)
+        elif amount < 10000000:
+            return round_to_nearest(amount, 1000000)
+        elif amount < 100000000:
+            return round_to_nearest(amount, 10000000)
+        else:
+            return round_to_nearest(amount, 1000)
+
+    def calculate_bet(self) -> int:
+        max_bet_ = self.max_bet()
+        min_bet_ = self.min_bet()
+        while max_bet_ > self.obj.balance:
+            max_bet_ -= min_bet_
+        return max_bet_

bot/core/api_js_helpers/upgrader.py

@@ -0,0 +1,90 @@
+import math
+
+
+class Calculator:
+    def get_price(self, data, level):
+        return self.calculate_formula(data.priceFormula, level, data.priceBasic, data.priceFormulaK) if level else 0
+
+    def get_profit(self, data, level):
+        return (
+            self.calculate_formula(data.profitFormula, level, data.profitBasic, data.priceFormulaK, data)
+            if level
+            else 0
+        )
+
+    def calculate_formula(self, formula, level, base_value, formula_coefficient, data=None):
+        result = base_value
+        if formula == "fnCompound":
+            result = self.fn_compound(level, base_value, formula_coefficient)
+        elif formula == "fnLogarithmic":
+            result = self.fn_logarithmic(level, base_value)
+        elif formula == "fnLinear":
+            result = self.fn_linear(level, base_value)
+        elif formula == "fnQuadratic":
+            result = self.fn_quadratic(level, base_value)
+        elif formula == "fnCubic":
+            result = self.fn_cubic(level, base_value)
+        elif formula == "fnExponential":
+            result = self.fn_exponential(level, base_value, formula_coefficient)
+        elif formula == "fnPayback":
+            result = self.fn_payback(level, data)
+
+        return self.smart_round(result)
+
+    def smart_round(self, value):
+        def round_to(value, factor=100):
+            return round(value / factor) * factor
+
+        if value < 50:
+            return round(value)
+        elif value < 100:
+            return round_to(value, 5)
+        elif value < 500:
+            return round_to(value, 25)
+        elif value < 1000:
+            return round_to(value, 50)
+        elif value < 5000:
+            return round_to(value, 100)
+        elif value < 10000:
+            return round_to(value, 200)
+        elif value < 100000:
+            return round_to(value, 500)
+        elif value < 500000:
+            return round_to(value, 1000)
+        elif value < 1000000:
+            return round_to(value, 5000)
+        elif value < 50000000:
+            return round_to(value, 10000)
+        elif value < 100000000:
+            return round_to(value, 50000)
+        else:
+            return round_to(value, 100000)
+
+    def fn_linear(self, level, base_value):
+        return base_value * level
+
+    def fn_quadratic(self, level, base_value):
+        return base_value * level * level
+
+    def fn_cubic(self, level, base_value):
+        return base_value * level * level * level
+
+    def fn_exponential(self, level, base_value, coefficient):
+        return base_value * math.pow(coefficient / 10, level)
+
+    def fn_logarithmic(self, level, base_value):
+        return base_value * math.log2(level + 1)
+
+    def fn_compound(self, level, base_value, coefficient):
+        compound_rate = coefficient / 100
+        return base_value * math.pow(1 + compound_rate, level - 1)
+
+    def fn_payback(self, level, data):
+        accumulated = [0]
+        for current_level in range(1, level + 1):
+            previous_accumulated = accumulated[current_level - 1]
+            current_price = self.get_price(data, current_level)
+            current_profit = data.profitBasic + data.profitFormulaK * (current_level - 1)
+            smart_rounded_value = self.smart_round(previous_accumulated + current_price / current_profit)
+            accumulated.append(smart_rounded_value)
+        return accumulated[level]

bot/core/bot.py

@@ -0,0 +1,427 @@
+import asyncio
+import math
+import random
+import time
+from collections.abc import Generator
+from datetime import datetime
+from enum import Enum
+
+import aiohttp
+from aiohttp_proxy import ProxyConnector
+from aiohttp_socks import ProxyConnector as SocksProxyConnector
+from pyrogram import Client
+from pytz import UTC
+
+from bot.config.headers import headers
+from bot.config.logger import log
+from bot.config.settings import Strategy, config
+from bot.core.api_js_helpers.bet_counter import BetCounter
+
+from .api import CryptoBotApi
+from .errors import TapsError
+from .models import DbSkill, DbSkills, Profile, ProfileData, SessionData, SkillLevel
+from .utils import load_codes_from_files, num_prettier
+
+
+class CryptoBot(CryptoBotApi):
+    def __init__(self, tg_client: Client, additional_data: dict) -> None:
+        super().__init__(tg_client)
+        self.temporary_stop_taps_time = 0
+        self.bet_calculator = BetCounter(self)
+        self.pvp_count = config.PVP_COUNT
+        self.authorized = False
+        self.settings_was_set = False
+        self.sleep_time = config.BOT_SLEEP_TIME
+        self.additional_data: SessionData = SessionData.model_validate(
+            {k: v for d in additional_data for k, v in d.items()}
+        )
+
+    async def claim_daily_reward(self) -> None:
+        for day, status in self.data_after.daily_rewards.items():
+            if status == "canTake":
+                await self.daily_reward(json_body={"data": str(day)})
+                self.logger.success("Daily reward claimed")
+                return
+
+    async def perform_taps(self, profile: Profile) -> None:
+        self.logger.info("Taps started")
+        energy = profile.energy
+        while True:
+            taps_per_second = random.randint(*config.TAPS_PER_SECOND)
+            seconds = random.randint(5, 8)
+            earned_money = profile.money_per_tap * taps_per_second * seconds
+            energy_spent = math.ceil(earned_money / 2)
+            energy -= energy_spent
+            if energy < 0:
+                self.logger.info("Taps stopped (not enough energy)")
+                break
+            await asyncio.sleep(delay=seconds)
+            try:
+                json_data = {
+                    "data": {
+                        "data": {"task": {"amount": earned_money, "currentEnergy": energy}},
+                        "seconds": seconds,
+                    }
+                }
+                energy = await self.api_perform_taps(json_body=json_data)
+                self.logger.success(
+                    f"Earned money: <y>+{num_prettier(earned_money)}</y> | Energy left: <blue>{num_prettier(energy)}</blue>"
+                )
+            except TapsError as e:
+                self.logger.warning(f"Taps stopped (<red>{e.message}</red>)")
+                self.temporary_stop_taps_time = time.monotonic() + 60 * 60 * 3
+                break
+
+    async def execute_and_claim_daily_quest(self) -> None:
+        helper_data = await self.get_helper()
+        helper_data.youtube.update(load_codes_from_files())
+        all_daily_quests = await self.all_daily_quests()
+        for key, value in all_daily_quests.items():
+            desc = value["description"]
+            if (
+                value["type"] == "youtube"
+                and not value["isRewarded"]
+                and (code := helper_data.youtube.get(value["description"])) is not None
+            ):
+                await self.daily_quest_reward(json_body={"data": {"quest": key, "code": str(code)}})
+                self.logger.info(f"Quest <g>{desc}</g> claimed")
+            elif desc:
+                self.logger.info(f"Quest not executed: \n<r>{desc}</r>")
+            if not value["isRewarded"] and value["isComplete"] and not value["url"]:
+                await self.daily_quest_reward(json_body={"data": {"quest": key, "code": None}})
+                self.logger.info(f"Quest <g>{key}</g> claimed")
+
+    async def claim_all_executed_quest(self) -> None:
+        for i in self.data_after.quests:
+            if not i["isRewarded"]:
+                if config.SKIP_IMPROVE_DISCIPLINE_BUG and i["key"] == "improve_discipline":
+                    continue
+                await self.quest_reward_claim(json_body={"data": [i["key"], None]})
+                self.logger.info(f'Quest <g>{i["key"]}</g> claimed ')
+
+    def random_pvp_count(self) -> int:
+        return random.randint(config.PVP_COUNT, config.PVP_COUNT * 2)
+
+    async def _perform_pvp(self, league: dict, strategy: str) -> None:
+        self.pvp_count = self.random_pvp_count()
+        self.logger.info(
+            f"PvP negotiations started | League: <blue>{league['key']}</blue> | Strategy: <g>{strategy}</g>"
+        )
+        res = await self.get_pvp_info()
+        await self.sleeper()
+        if res.get("fight"):
+            await self.get_pvp_claim()
+            await self.sleeper()
+        current_strategy = strategy
+        money = 0
+        while self.pvp_count > 0:
+            if self.balance < int(league["maxContract"]):
+                money_str = (
+                    f"Profit: <y>+{num_prettier(money)}</y>"
+                    if money >= 0
+                    else f"Loss: <red>-{num_prettier(money)}</red>"
+                )
+                self.logger.info(f"PvP negotiations stopped (<red>not enough money</red>). Pvp profit: {money_str}")
+                break
+
+            if strategy == "random":
+                current_strategy = random.choice(self.strategies)
+            self.logger.info("Searching opponent...")
+            current_strategy = current_strategy.value if isinstance(current_strategy, Enum) else current_strategy
+            json_data = {"data": {"league": league["key"], "strategy": current_strategy}}
+            response_json = await self.get_pvp_fight(json_body=json_data)
+            if response_json is None:
+                await self.sleeper(delay=10, additional_delay=5)
+                continue
+
+            fight = response_json.fight
+            opponent_strategy = (
+                fight.player2Strategy if fight.player1 == self.user_profile.user_id else fight.player1Strategy
+            )
+            if fight.winner == self.user_profile.user_id:
+                money += fight.moneyProfit
+                log_part = f"You <g>WIN</g> (<y>+{num_prettier(fight.moneyProfit)})</y>"
+            else:
+                money -= fight.moneyContract
+                log_part = f"You <red>LOSE</red> (<y>-{num_prettier(fight.moneyProfit)}</y>)"
+            self.logger.success(
+                f"Contract sum: <y>{num_prettier(fight.moneyContract)}</y> | "
+                f"Your strategy: <c>{current_strategy}</c> | "
+                f"Opponent strategy: <blue>{opponent_strategy}</blue> | "
+                f"{log_part}"
+            )
+            await self.sleeper(additional_delay=10)
+            await self.get_pvp_claim()
+            self.pvp_count -= 1
+            await self.sleeper()
+
+        self.logger.info(
+            "Total money after all pvp:"
+            + (f"<i><g>+{num_prettier(money)}</g></i>" if money >= 0 else f"<i><red>{num_prettier(money)}</red></i>")
+        )
+        self.pvp_count = config.PVP_COUNT
+
+    async def get_friend_reward(self) -> None:
+        for friend in [friend for friend in self.data_after.friends if friend["bonusToTake"] > 0]:
+            await self.friend_reward(json_body={"data": friend["id"]})
+            self.logger.info(
+                f"Friend <g>{friend['name']}</g> claimed money <y>{num_prettier(friend['bonusToTake'])}</y>"
+            )
+            await self.sleeper()
+
+    async def solve_quiz_and_rebus(self) -> None:
+        for quest in self.dbs["dbQuests"]:
+            quest_key = quest["key"]
+            if quest["requiredLevel"] > self.user_profile.level:
+                continue
+            if "t.me" in (link := quest.get("actionUrl")) and not self._is_event_solved(quest_key):
+                if len(link.split("/")) > 4 or "muskempire" in link:
+                    continue
+                if quest["checkType"] != "fakeCheck":
+                    link = link if "/+" in link else link.split("/")[-1]
+                    await self.join_and_archive_channel(link)
+                await self.quest_check(json_body={"data": [quest_key]})
+                self.logger.info(
+                    f'Claimed <g>{quest["title"]}</g> Reward: <y>+{num_prettier(quest["rewardMoney"])}</y>quest'
+                )
+            if any(i in quest_key for i in ("riddle", "rebus", "tg_story")) and not self._is_event_solved(quest_key):
+                await self.quest_check(json_body={"data": [quest_key, quest["checkData"]]})
+                self.logger.info(f"Was solved <g>{quest['title']}</g>")
+
+    def _is_event_solved(self, quest_key: str) -> bool:
+        return self.data_after.quests and any(i["key"] == quest_key for i in self.data_after.quests)
+
+    async def set_funds(self) -> None:
+        helper_data = await self.get_helper()
+        if helper_data.funds:
+            current_invest = await self.get_funds_info()
+            already_funded = {i["fundKey"] for i in current_invest["funds"]}
+            for fund in list(helper_data.funds - already_funded)[: 3 - len(already_funded)]:
+                if self.balance > (amount := self.bet_calculator.calculate_bet()):
+                    self.logger.info(f"Investing <y>{num_prettier(amount)}</y> to  fund <blue>{fund}</blue>")
+                    await self.invest(json_body={"data": {"fund": fund, "money": amount}})
+                else:
+                    self.logger.info("Not enough money for invest")
+
+    async def starting_pvp(self) -> None:
+        if self.dbs:
+            league_data = None
+            for league in self.dbs["dbNegotiationsLeague"]:
+                if league["key"] == config.PVP_LEAGUE:
+                    league_data = league
+                    break
+
+            if league_data is not None:
+                if self.level >= int(league_data["requiredLevel"]):
+                    self.strategies = [strategy["key"] for strategy in self.dbs["dbNegotiationsStrategy"]]
+                    if Strategy.random == config.PVP_STRATEGY or config.PVP_STRATEGY in self.strategies:
+                        await self._perform_pvp(
+                            league=league_data,
+                            strategy=config.PVP_STRATEGY.value,
+                        )
+                    else:
+                        config.PVP_ENABLED = False
+                        self.logger.warning("PVP_STRATEGY param is invalid. PvP negotiations disabled.")
+                else:
+                    config.PVP_ENABLED = False
+                    self.logger.warning(
+                        f"Your level is too low for the {config.PVP_LEAGUE} league. PvP negotiations disabled."
+                    )
+            else:
+                config.PVP_ENABLED = False
+                self.logger.warning("PVP_LEAGUE param is invalid. PvP negotiations disabled.")
+        else:
+            self.logger.warning("Database is missing. PvP negotiations will be skipped this time.")
+
+    async def upgrade_hero(self) -> None:
+        available_skill = list(self._get_available_skills())
+        if config.AUTO_UPGRADE_HERO:
+            await self._upgrade_hero_skill(available_skill)
+        if config.AUTO_UPGRADE_MINING:
+            await self._upgrade_mining_skill(available_skill)
+
+    async def get_box_rewards(self) -> None:
+        boxes = await self.get_box_list()
+        for key, box_count in boxes.items():
+            for _ in range(box_count):
+                res = await self.box_open(json_body={"data": key})
+                self.logger.info(f"Box <g>{key}</g> Was looted: <y>{res['loot']}</y>")
+
+    async def _upgrade_mining_skill(self, available_skill: list[DbSkill]) -> None:
+        for skill in [skill for skill in available_skill if skill.category == "mining"]:
+            if (
+                skill.key in config.MINING_ENERGY_SKILLS
+                and skill.next_level <= config.MAX_MINING_ENERGY_RECOVERY_UPGRADE_LEVEL
+                or (
+                    skill.next_level <= config.MAX_MINING_UPGRADE_LEVEL
+                    or skill.skill_price <= config.MAX_MINING_UPGRADE_COSTS
+                )
+            ):
+                await self._upgrade_skill(skill)
+
+    def _is_enough_money_for_upgrade(self, skill: DbSkill) -> bool:
+        return (self.balance - skill.skill_price) >= config.MONEY_TO_SAVE
+
+    async def _upgrade_hero_skill(self, available_skill: list[DbSkill]) -> None:
+        for skill in sorted(
+            [skill for skill in available_skill if skill.weight],
+            key=lambda x: x.weight,
+            reverse=True,
+        ):
+            if skill.title in config.SKIP_TO_UPGRADE_SKILLS:
+                continue
+            # if skill.weight >= config.SKILL_WEIGHT or skill.skill_price <= config.MAX_SKILL_UPGRADE_COSTS:
+            if skill.weight >= config.SKILL_WEIGHT:
+                await self._upgrade_skill(skill)
+
+    async def _upgrade_skill(self, skill: DbSkill) -> None:
+        if self._is_enough_money_for_upgrade(skill):
+            try:
+                await self.skills_improve(json_body={"data": skill.key})
+                self.logger.info(
+                    f"Skill: <blue>{skill.title}</blue> upgraded to level: <c>{skill.next_level}</c> "
+                    f"Profit: <y>{num_prettier(skill.skill_profit)}</y> "
+                    f"Costs: <blue>{num_prettier(skill.skill_price)}</blue> "
+                    f"Money stay: <y>{num_prettier(self.balance)}</y> "
+                    f"Skill weight <magenta>{skill.weight:.5f}</magenta>"
+                )
+                await self.sleeper()
+            except ValueError:
+                self.logger.exception(f"Failed to upgrade skill: {skill}")
+                raise
+
+    def _get_available_skills(self) -> Generator[DbSkill, None, None]:
+        for skill in DbSkills(**self.dbs).dbSkills:
+            self._calkulate_skill_requirements(skill)
+            if self._is_available_to_upgrade_skills(skill):
+                yield skill
+
+    def _calkulate_skill_requirements(self, skill: DbSkill) -> None:
+        skill.next_level = (
+            self.data_after.skills[skill.key]["level"] + 1 if self.data_after.skills.get(skill.key) else 1
+        )
+        skill.skill_profit = skill.calculate_profit(skill.next_level)
+        skill.skill_price = skill.price_for_level(skill.next_level)
+        skill.weight = skill.skill_profit / skill.skill_price
+        skill.progress_time = skill.get_skill_time(self.data_after)
+
+    def _is_available_to_upgrade_skills(self, skill: DbSkill) -> bool:
+        # check the current skill is still in the process of improvement
+        if skill.progress_time and skill.progress_time.timestamp() + 60 > datetime.now(UTC).timestamp():
+            return False
+        if skill.next_level > skill.maxLevel:
+            return False
+        skill_requirements = skill.get_level_by_skill_level(skill.next_level)
+        if not skill_requirements:
+            return True
+        return (
+            len(self.data_after.friends) >= skill_requirements.requiredFriends
+            and self.user_profile.level >= skill_requirements.requiredHeroLevel
+            and self._is_can_learn_skill(skill_requirements)
+        )
+
+    def _is_can_learn_skill(self, level: SkillLevel) -> bool:
+        if not level.requiredSkills:
+            return True
+        for skill, level in level.requiredSkills.items():
+            if skill not in self.data_after.skills:
+                return False
+            if self.data_after.skills[skill]["level"] >= level:
+                return True
+        return False
+
+    async def login_to_app(self, proxy: str | None) -> bool:
+        if self.authorized:
+            return True
+        tg_web_data = await self.get_tg_web_data(proxy=proxy)
+        self.http_client.headers["Api-Key"] = tg_web_data.hash
+        if await self.login(json_body=tg_web_data.request_data):
+            self.authorized = True
+            return True
+        return False
+
+    async def run(self, proxy: str | None) -> None:
+        proxy = proxy or self.additional_data.proxy
+        if proxy and "socks" in proxy:
+            proxy_conn = SocksProxyConnector.from_url(proxy)
+        elif proxy:
+            proxy_conn = ProxyConnector.from_url(proxy)
+        else:
+            proxy_conn = None
+
+        async with aiohttp.ClientSession(
+            headers=headers,
+            connector=proxy_conn,
+            timeout=aiohttp.ClientTimeout(total=60),
+        ) as http_client:
+            self.http_client = http_client
+            if proxy:
+                await self.check_proxy(proxy=proxy)
+
+            while True:
+                if self.errors >= config.ERRORS_BEFORE_STOP:
+                    self.logger.error("Bot stopped (too many errors)")
+                    break
+                try:
+                    if await self.login_to_app(proxy):
+                        # if not self.settings_was_set:
+                        #     await self.sent_eng_settings()
+                        data = await self.get_profile_full()
+                        self.dbs = data["dbData"]
+                        await self.get_box_rewards()
+
+                        self.user_profile: ProfileData = ProfileData(**data)
+                        if self.user_profile.offline_bonus > 0:
+                            await self.get_offline_bonus()
+
+                    profile = await self.syn_hero_balance()
+
+                    config.MONEY_TO_SAVE = self.bet_calculator.max_bet()
+                    self.logger.info(f"Max bet for funds saved: <y>{num_prettier(config.MONEY_TO_SAVE)}</y>")
+
+                    self.data_after = await self.user_data_after()
+
+                    await self.claim_daily_reward()
+
+                    await self.execute_and_claim_daily_quest()
+
+                    await self.syn_hero_balance()
+
+                    await self.get_friend_reward()
+
+                    if config.TAPS_ENABLED and profile.energy and time.monotonic() > self.temporary_stop_taps_time:
+                        await self.perform_taps(profile)
+
+                    await self.set_funds()
+                    await self.solve_quiz_and_rebus()
+
+                    await self.claim_all_executed_quest()
+
+                    await self.syn_hero_balance()
+
+                    await self.upgrade_hero()
+
+                    if config.PVP_ENABLED:
+                        await self.starting_pvp()
+                    await self.syn_hero_balance()
+                    sleep_time = random.randint(*config.BOT_SLEEP_TIME)
+                    self.logger.info(f"Sleep minutes {sleep_time // 60} minutes")
+                    await asyncio.sleep(sleep_time)
+
+                except RuntimeError as error:
+                    raise error from error
+                except Exception:
+                    self.errors += 1
+                    self.authorized = False
+                    self.logger.exception("Unknown error")
+                    await self.sleeper(additional_delay=self.errors * 8)
+                else:
+                    self.errors = 0
+                    self.authorized = False
+
+
+async def run_bot(tg_client: Client, proxy: str | None, additional_data: dict) -> None:
+    try:
+        await CryptoBot(tg_client=tg_client, additional_data=additional_data).run(proxy=proxy)
+    except RuntimeError:
+        log.bind(session_name=tg_client.name).exception("Session error")

bot/core/errors.py

@@ -0,0 +1,3 @@
+class TapsError(Exception):
+    def __init__(self, message: str) -> None:
+        self.message = message

bot/core/models.py

@@ -0,0 +1,219 @@
+from datetime import datetime
+from typing import Any
+
+from pydantic import AliasPath, BaseModel, Field, field_validator
+from pytz import UTC
+
+from bot.core.api_js_helpers.upgrader import Calculator
+
+
+class SkillLevel(BaseModel):
+    level: int
+    title: str
+    requiredSkills: dict | list
+    requiredHeroLevel: int
+    requiredFriends: int
+    desc: str
+
+
+class DbSkill(BaseModel):
+    key: str
+    title: str
+    category: str
+    subCategory: str
+    priceBasic: int
+    priceFormula: str
+    priceFormulaK: int
+    profitBasic: int
+    profitFormula: str
+    profitFormulaK: int
+    maxLevel: int
+    timeBasic: str
+    timeFormula: str
+    timeFormulaK: str
+    desc: str
+    special: str
+    levels: list[SkillLevel]
+    next_level: int = 1
+    skill_profit: int = 0
+    skill_price: int = 0
+    weight: int = 0
+    progress_time: datetime | None = None
+
+    def __init__(self, /, **data: Any) -> None:
+        super().__init__(**data)
+        self._calculator = Calculator()
+
+    def get_level_by_skill_level(self, level: int) -> SkillLevel | None:
+        if not self.levels or self.levels[0].level > level:
+            return None
+
+        for index, skill_level in enumerate(self.levels):
+            if skill_level.level <= level:
+                if index + 1 == len(self.levels):
+                    return skill_level
+                if self.levels[index + 1].level > level:
+                    return skill_level
+
+        return None
+
+    def calculate_profit(self, level: int) -> int:
+        return self._calculator.get_profit(self, level)
+
+    def price_for_level(self, level: int) -> int:
+        return self._calculator.get_price(self, level)
+
+    def get_skill_time(self, data_after: "UserDataAfter") -> None | datetime:
+        if finish_time := data_after.skills.get(self.key, {}).get("finishUpgradeDate"):
+            return datetime.strptime(finish_time, "%Y-%m-%d %H:%M:%S").replace(tzinfo=UTC)
+        return None
+
+
+class DbSkills(BaseModel):
+    dbSkills: list[DbSkill]
+
+
+class ProfileData(BaseModel):
+    user_id: int = Field(validation_alias=AliasPath("profile", "id"))
+    money: int = Field(validation_alias=AliasPath("hero", "money"))
+    level: int = Field(validation_alias=AliasPath("hero", "level"))
+    money_per_hour: int = Field(validation_alias=AliasPath("hero", "moneyPerHour"))
+    offline_bonus: int = Field(validation_alias=AliasPath("hero", "offlineBonus"))
+
+
+class UserDataAfter(BaseModel):
+    daily_rewards: dict = Field(validation_alias=AliasPath("dailyRewards"))
+    quests: list = Field(validation_alias=AliasPath("quests"))
+    friends: list = Field(validation_alias=AliasPath("friends"))
+    skills: dict | list = Field(
+        description="all user learned skills",
+        examples=[
+            {"desks": {"level": 6, "lastUpgradeDate": "2024-07-30 19:20:32", "finishUpgradeDate": None}},
+            {
+                "empathy": {
+                    "level": 6,
+                    "lastUpgradeDate": "2024-07-30 19:21:36",
+                    "finishUpgradeDate": "2024-07-30 19:22:13",
+                }
+            },
+        ],
+    )
+
+    @field_validator("skills")
+    @classmethod
+    def check_skills(cls, v: Any) -> dict:
+        return v or {}
+
+
+class Profile(BaseModel):
+    money_per_tap: int = Field(validation_alias=AliasPath("hero", "earns", "task", "moneyPerTap"))
+    limit: int = Field(validation_alias=AliasPath("hero", "earns", "task", "limit"))
+    energy: int = Field(validation_alias=AliasPath("hero", "earns", "task", "energy"))
+    energy_recovery: int = Field(validation_alias=AliasPath("hero", "earns", "task", "recoveryPerSecond"))
+
+    money: int = Field(validation_alias=AliasPath("hero", "money"))
+    level: int = Field(validation_alias=AliasPath("hero", "level"))
+    money_per_hour: int = Field(validation_alias=AliasPath("hero", "moneyPerHour"))
+
+
+class Fight(BaseModel):
+    league: str
+    moneyProfit: int
+    player1: int
+    moneyContract: int
+    player1Strategy: str
+    player1Level: int
+    player1Rewarded: bool
+    player2: int
+    player2Strategy: str
+    player2Rewarded: bool
+    winner: int
+
+
+class PvpData(BaseModel):
+    opponent: dict | None
+    fight: Fight | None
+
+
+class FundHelper(BaseModel):
+    funds: set = Field(default_factory=set)
+    youtube: dict
+
+
+class Skills(BaseModel):
+    skills: dict
+
+
+if __name__ == "__main__":
+    data = {
+        "hero": {
+            "id": 1092379081,
+            "level": 12,
+            "exp": 207156950,
+            "money": 8154952,
+            "moneyUpdateDate": "2024-08-05 07:02:28",
+            "lastOfflineBonusDate": "2024-08-05 07:02:28",
+            "moneyPerHour": 7943050,
+            "energyUpdateDate": "2024-08-05 07:02:28",
+            "tax": 20,
+            "pvpMatch": 1143,
+            "pvpWin": 646,
+            "pvpLose": 497,
+            "pvpMatchesDaily": 123,
+            "pvpMatchesDailyDay": "2024-08-04",
+            "earns": {
+                "task": {"moneyPerTap": 21, "limit": 9500, "energy": 9500, "recoveryPerSecond": 14},
+                "sell": {"moneyPerTap": 20, "limit": 6600, "energy": 6600, "recoveryPerSecond": 14},
+            },
+            "dailyRewardLastDate": "2024-08-04 11:15:56",
+            "dailyRewardLastIndex": 7,
+            "onboarding": [
+                "9040",
+                "41",
+                "30",
+                "40",
+                "9000",
+                "90",
+                "70",
+                "10720",
+                "9020",
+                "10015",
+                "9010",
+                "80",
+                "50",
+                "10700",
+                "60",
+                "9030",
+                "20",
+                "51",
+                "1",
+            ],
+            "updateDate": "2024-07-19 16:39:56.91573",
+            "userId": 1092379081,
+        },
+        "fight": {
+            "id": "08999015-6835-44ed-b00e-3ac529b62285",
+            "league": "bronze",
+            "moneyContract": 6600,
+            "moneyProfit": None,
+            "searchTime": None,
+            "player1": 1092379081,
+            "player1Strategy": "aggressive",
+            "player1Level": 12,
+            "player1Rewarded": False,
+            "player2": None,
+            "player2Strategy": None,
+            "player2Rewarded": False,
+            "winner": None,
+            "draw": [],
+            "updateDate": None,
+            "creationDate": "2024-08-05 07:02:35",
+        },
+        "opponent": None,
+    }
+    PvpData(**data)
+
+
+class SessionData(BaseModel):
+    user_agent: str = Field(validation_alias="User-Agent")
+    proxy: str | None = None

bot/core/utils.py

@@ -0,0 +1,24 @@
+import json
+from functools import lru_cache
+from pathlib import Path
+
+
+@lru_cache
+def load_codes_from_files() -> dict:
+    with Path("youtube.json").open("r", encoding="utf-8") as file:
+        return json.load(file)
+
+
+def num_prettier(num: int) -> str:
+    number = abs(num)
+    if number >= (comparer := 1e12):
+        prettier_num = f"{number / comparer:.1f}T"
+    elif number >= (comparer := 1e9):
+        prettier_num = f"{number / comparer:.1f}B"
+    elif number >= (comparer := 1e6):
+        prettier_num = f"{number / comparer:.1f}M"
+    elif number >= (comparer := 1e3):
+        prettier_num = f"{number / comparer:.1f}k"
+    else:
+        prettier_num = str(number)
+    return f"-{prettier_num}" if num < 0 else prettier_num

bot/helper/utils.py

@@ -0,0 +1,89 @@
+import asyncio
+import hashlib
+import json
+import random
+from collections.abc import Callable
+from functools import wraps
+from time import time
+
+import aiohttp
+from loguru import logger
+
+
+def error_handler(delay=3):
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except Exception as error:
+                logger.error(f"Error in {func.__name__}: {error}")
+                await asyncio.sleep(random.randint(delay, delay * 2))
+                raise
+
+        return wrapper
+
+    return decorator
+
+
+def handle_request(
+    endpoint: str,
+    full_url: bool = False,
+    method: str = "POST",
+    raise_for_status: bool = True,
+    json_body: dict | None = None,
+):
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(self, *args, **kwargs):
+            url = endpoint if full_url else self.api_url + endpoint
+            if method.upper() == "POST":
+                _json_body = kwargs.get("json_body") or json_body or {}
+                set_sign_headers(http_client=self.http_client, data=_json_body)
+                response = await self.http_client.post(url, json=_json_body)
+            elif method.upper() == "GET":
+                response = await self.http_client.get(url)
+            else:
+                msg = "Unsupported HTTP method"
+                raise ValueError(msg)
+            if raise_for_status:
+                response.raise_for_status()
+
+            content_type = response.headers.get("Content-Type", "")
+            if "application/json" in content_type:
+                response_data = await response.json()
+            elif "text/" in content_type:
+                response_data = await response.text()
+            else:
+                response_data = await response.read()
+            return await func(self, response_json=response_data, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def set_sign_headers(http_client: aiohttp.ClientSession, data: dict) -> None:
+    time_string = str(int(time()))
+    json_string = json.dumps(data)
+    hash_object = hashlib.md5()
+    hash_object.update(f"{time_string}_{json_string}".encode())
+    hash_string = hash_object.hexdigest()
+    http_client.headers["Api-Time"] = time_string
+    http_client.headers["Api-Hash"] = hash_string
+
+
+def error_handler(delay=3):
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(self, *args, **kwargs):
+            try:
+                return await func(self, *args, **kwargs)
+            except Exception as error:
+                self.logger.error(f"Error in {func.__name__}: {error}")
+                await asyncio.sleep(random.randint(delay, delay * 2))
+                raise
+
+        return wrapper
+
+    return decorator

bot/launcher.py

@@ -0,0 +1,129 @@
+import asyncio
+import random
+from argparse import ArgumentParser
+from itertools import cycle
+from pathlib import Path
+from typing import NamedTuple
+
+from better_proxy import Proxy
+from pyrogram import Client
+
+from bot.config.logger import log
+from bot.config.settings import config, logo
+from bot.core.bot import run_bot
+from bot.utils import get_session_profiles
+
+start_text = """
+    Select an action:
+        1. Create session
+        2. Run bot
+    """
+
+
+class SessionData(NamedTuple):
+    tg_client: Client
+    session_data: dict
+
+
+def get_session_names() -> list[str]:
+    return [file.stem for file in sorted(Path("sessions").glob("*.session"))]
+
+
+async def register_sessions() -> None:
+    session_name = input("\nEnter the session name (press Enter to exit): ")
+    if not session_name:
+        return
+
+    sessions_path = Path("sessions")
+    if not sessions_path.exists():
+        sessions_path.mkdir()
+
+    session = Client(
+        name=session_name,
+        api_id=config.API_ID,
+        api_hash=config.API_HASH,
+        workdir="sessions/",
+    )
+
+    async with session:
+        user_data = await session.get_me()
+    log.success(
+        f"Session added successfully: {user_data.username or user_data.id} | "
+        f"{user_data.first_name or ''} {user_data.last_name or ''}"
+    )
+
+
+def get_proxies() -> [str | None]:
+    if config.USE_PROXY_FROM_FILE:
+        with Path("proxies.txt").open(encoding="utf-8") as file:
+            return [Proxy.from_str(proxy=row.strip()).as_url for row in file if row.strip()]
+    return None
+
+
+async def get_tg_clients() -> list[SessionData]:
+    session_names = get_session_names()
+
+    if not session_names:
+        msg = "Not found session files"
+        raise FileNotFoundError(msg)
+    session_profiles = get_session_profiles(session_names)
+    return [
+        SessionData(
+            tg_client=Client(
+                name=session_name,
+                api_id=config.API_ID,
+                api_hash=config.API_HASH,
+                workdir="sessions/",
+            ),
+            session_data=session_profiles[session_name],
+        )
+        for session_name in session_names
+    ]
+
+
+async def run_bot_with_delay(tg_client: Client, proxy: str | None, additional_data: dict, session_index: int) -> None:
+    delay = session_index * config.SESSION_AC_DELAY + random.randint(*config.SLEEP_BETWEEN_START)
+    log.bind(session_name=tg_client.name).info(f"Wait {delay} seconds before start")
+    await asyncio.sleep(delay)
+    await run_bot(tg_client=tg_client, proxy=proxy, additional_data=additional_data)
+
+
+async def run_clients(session_data: list[SessionData]) -> None:
+    proxies = get_proxies() or [None]
+    if config.ADD_LOCAL_MACHINE_AS_IP:
+        proxies.append(None)
+    proxy_cycle = cycle(proxies)
+    await asyncio.gather(
+        *[
+            run_bot_with_delay(
+                tg_client=s_data.tg_client,
+                proxy=next(proxy_cycle),
+                additional_data=s_data.session_data,
+                session_index=index,
+            )
+            for index, s_data in enumerate(session_data)
+        ]
+    )
+
+
+async def start() -> None:
+    print(logo)
+    parser = ArgumentParser()
+    parser.add_argument("-a", "--action", type=int, choices=[1, 2], help="Action to perform  (1 or 2)")
+    log.info(f"Detected {len(get_session_names())} sessions | {len(proxy) if (proxy := get_proxies()) else 0} proxies")
+    action = parser.parse_args().action
+
+    if not action:
+        print(start_text)
+        while True:
+            action = input("> ").strip()
+            if action.isdigit() and action in ["1", "2"]:
+                action = int(action)
+                break
+            log.warning("Action must be a number (1 or 2)")
+
+    if action == 1:
+        await register_sessions()
+    elif action == 2:
+        session_data = await get_tg_clients()
+        await run_clients(session_data=session_data)

bot/utils.py

@@ -0,0 +1,34 @@
+import json
+from pathlib import Path
+
+from fake_useragent import UserAgent
+
+
+def read_session_profiles(sessions: list[str]) -> dict | None:
+    file_path = Path("session_profile.json")
+    if not file_path.exists():
+        return None
+
+    try:
+        with file_path.open(encoding="utf-8") as file:
+            data = json.load(file)
+            return data if all(session in data and len(data[session]) >= 2 for session in sessions) else None
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def get_session_profiles(sessions: list[str]) -> dict:
+    session_profiles = read_session_profiles(sessions)
+    if session_profiles is None:
+        session_profiles = {}
+        ua_generator = UserAgent(browsers=["safari"], os=["ios"], platforms=["mobile", "tablet"])
+
+        for session in sessions:
+            inner = session_profiles.setdefault(session, [])
+            inner.append({"User-Agent": ua_generator.random})
+            inner.append({"proxy": None})
+
+        with Path("session_profile.json").open("w", encoding="utf-8") as file:
+            json.dump(session_profiles, file, ensure_ascii=False, indent=4)
+
+    return session_profiles

docker-compose.yml

@@ -0,0 +1,14 @@
+version: '3'
+services:
+    bot:
+        container_name: 'MuskEmpireBot'
+        stop_signal: SIGINT
+        build:
+            context: .
+        working_dir: /app
+        volumes:
+            - .:/app
+        entrypoint: "python3 main.py"
+        command: ["-a", "2"]
+        restart: unless-stopped
+        env_file: .env

main.py

@@ -0,0 +1,15 @@
+import asyncio
+
+from bot import launcher
+from bot.config.logger import log
+
+
+async def main() -> None:
+    await launcher.start()
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        log.info("Bot stopped by user")

proxies.txt

@@ -0,0 +1,5 @@
+type://user:pass@ip:port
+type://user:pass:ip:port
+type://ip:port:user:pass
+type://ip:port@user:pass
+type://ip:port

requirements.txt

@@ -0,0 +1,11 @@
+pydantic-settings==2.3.4
+aiohttp==3.10.2
+better-proxy==1.2.0
+loguru==0.7.2
+Pyrogram==2.0.106
+TgCrypto==1.2.5
+aiocache==0.12.2
+pytz==2024.1
+fake-useragent==1.5.1
+aiohttp-socks==0.9.0
+aiohttp-proxy==0.1.2

youtube.json

@@ -0,0 +1,25 @@
+{
+  "From Queens to billionaire: the real story of Donald Trump. Controversy, power, wealth, and success": 2007,
+  "How сloud storage works? Episode 28": 75928,
+  "How biomimicry is changing the World. Episode 27": 35527,
+  "The Bezos phenomenon. The billionaire's path from the garage to space.": 0,
+  "How will AI change the world? Episode 29": 34329,
+  "What does a CEO really do? Episode 32": 12932,
+  "Marketing magic: turning Ordinary into Extraordinary. Episode 35": 15235,
+  "The secrets of multicurrency transfers. Episode 38": 22938,
+  "Who’s behind your crypto transfers? Episode 39": 44139,
+  "Check out the guide on how to connect your wallet and complete a test transaction. Once you've reviewed it, connect your wallet to participate in the Airdrop!": 3,
+  "How Sam Altman Is changing the AI world and what’s behind his popularity?": 2023,
+  "Bioengineering: medical miracles of tomorrow. Episode 37": 72837,
+  "Turning Creativity Into Cash: Intellectual Property Valuation. Episode 40": 65340,
+  "Corporate Anthropology: the art of Improving team work. Episode 41": 10941,
+  "The truth about Inflation. Episode 42": 83242,
+  "Mining secrets: How digital currency Is really made? Episode 43": 87843,
+  "Broker secrets: how they make your money work? Episode 44": 62944,
+  "From dorm room to tech Icon: Zuckerberg's story!": 2011,
+  "Why personal branding is the key to success? Episode 47": 24147,
+  "The power of strategic thinking: Think long-term, win big! Episode 50": 89350,
+  "Steve Jobs: Innovator, leader, enigma. The truth about the man behind Apple!": 1989,
+  "The Hidden Power and Harm of Monopolies. Episode 51": 37251,
+  "Reshoring: why Global businesses are coming home? Episode 49": 52649
+}