реализуй код на пайтон используя aiogram asyncio ...

Ниже простая версия для виртуальных монет, без реальных денег. Я взял aiogram 3.x: в актуальной версии используется Dispatcher.start_polling() для long polling. (docs.aiogram.dev)

Установка:

bash
pip install aiogram

bot.py:

python
import asyncio
import os
import secrets
from decimal import Decimal, ROUND_DOWN, InvalidOperation

from aiogram import Bot, Dispatcher, F
from aiogram.types import Message
from aiogram.filters import CommandStart


TOKEN = os.getenv("BOT_TOKEN")  # сюда токен: export BOT_TOKEN="123:ABC"

START_BALANCE = Decimal("1000.00")

COEF_COLOR = Decimal("1.98")
COEF_PARITY = Decimal("1.98")
COEF_NUMBER = Decimal("35.98")
COEF_RANGE = Decimal("1.98")

balances: dict[int, Decimal] = {}
locks: dict[int, asyncio.Lock] = {}

RED_NUMBERS = {
    1, 3, 5, 7, 9, 12, 14, 16, 18,
    19, 21, 23, 25, 27, 30, 32, 34, 36
}


def money(value: Decimal) -> str:
    return str(value.quantize(Decimal("0.01"), rounding=ROUND_DOWN))


def get_balance(user_id: int) -> Decimal:
    if user_id not in balances:
        balances[user_id] = START_BALANCE
    return balances[user_id]


def get_lock(user_id: int) -> asyncio.Lock:
    if user_id not in locks:
        locks[user_id] = asyncio.Lock()
    return locks[user_id]


def parse_amount(text: str) -> Decimal | None:
    try:
        amount = Decimal(text.replace(",", "."))
        amount = amount.quantize(Decimal("0.01"), rounding=ROUND_DOWN)
        if amount <= 0:
            return None
        return amount
    except InvalidOperation:
        return None


def normalize_bet_type(raw: str) -> str | None:
    bet = raw.lower().replace("ё", "е").strip()

    aliases = {
        "к": "red",
        "красное": "red",
        "красный": "red",
        "red": "red",

        "ч": "black",
        "черное": "black",
        "черный": "black",
        "black": "black",

        "чет": "even",
        "четное": "even",

        "нечет": "odd",
        "нечетное": "odd",

        "1-18": "low",
        "1_18": "low",
        "малые": "low",

        "19-36": "high",
        "19_36": "high",
        "большие": "high",
    }

    if bet in aliases:
        return aliases[bet]

    if bet.isdigit():
        number = int(bet)
        if 0 <= number <= 36:
            return f"number:{number}"

    return None


def get_number_info(number: int) -> str:
    if number == 0:
        return "🟢 0"

    if number in RED_NUMBERS:
        color = "🔴 красное"
    else:
        color = "⚫ черное"

    parity = "чет" if number % 2 == 0 else "нечет"
    range_text = "1-18" if 1 <= number <= 18 else "19-36"

    return f"{color}, {parity}, {range_text}"


def check_win(number: int, bet_type: str) -> tuple[bool, Decimal]:
    if bet_type == "red":
        return number in RED_NUMBERS, COEF_COLOR

    if bet_type == "black":
        return number != 0 and number not in RED_NUMBERS, COEF_COLOR

    if bet_type == "even":
        return number != 0 and number % 2 == 0, COEF_PARITY

    if bet_type == "odd":
        return number != 0 and number % 2 != 0, COEF_PARITY

    if bet_type == "low":
        return 1 <= number <= 18, COEF_RANGE

    if bet_type == "high":
        return 19 <= number <= 36, COEF_RANGE

    if bet_type.startswith("number:"):
        chosen = int(bet_type.split(":")[1])
        return number == chosen, COEF_NUMBER

    return False, Decimal("0")


def help_text() -> str:
    return (
        "🎡 <b>Рулетка | Lites 🃏</b>\n\n"
        "Команда:\n"
        "<code>рул [сумма] [тип]</code>\n\n"
        "Примеры:\n"
        "<code>рул 100 к</code>\n"
        "<code>рул 50 ч</code>\n"
        "<code>рул 25 чет</code>\n"
        "<code>рул 10 17</code>\n"
        "<code>рул 100 1-18</code>\n\n"
        "Ставки:\n"
        "• 💰 к / ч — цвет, x1.98\n"
        "• 💰 чет / нечет — x1.98\n"
        "• 💰 0-36 — число, x35.98\n"
        "• 💰 1-18 / 19-36 — x1.98\n\n"
        "Баланс: <code>баланс</code>"
    )


dp = Dispatcher()


@dp.message(CommandStart())
async def start_handler(message: Message):
    user_id = message.from_user.id
    balance = get_balance(user_id)

    await message.answer(
        f"{help_text()}\n\n"
        f"💰 Твой баланс: <b>{money(balance)}</b>"
    )


@dp.message(F.text.lower() == "баланс")
async def balance_handler(message: Message):
    user_id = message.from_user.id
    balance = get_balance(user_id)

    await message.answer(f"💰 Баланс: <b>{money(balance)}</b>")


@dp.message(F.text.lower().startswith("рул"))
async def roulette_handler(message: Message):
    user_id = message.from_user.id
    text = message.text.strip()
    parts = text.split(maxsplit=2)

    if len(parts) != 3:
        await message.answer(help_text())
        return

    amount = parse_amount(parts[1])
    if amount is None:
        await message.answer("❌ Сумма должна быть положительным числом. Например: <code>рул 100 к</code>")
        return

    bet_type = normalize_bet_type(parts[2])
    if bet_type is None:
        await message.answer("❌ Неверный тип ставки.\n\n" + help_text())
        return

    lock = get_lock(user_id)

    async with lock:
        balance = get_balance(user_id)

        if amount > balance:
            await message.answer(
                f"❌ Недостаточно монет.\n"
                f"💰 Баланс: <b>{money(balance)}</b>"
            )
            return

        # Сначала снимаем ставку
        balances[user_id] = balance - amount

        result_number = secrets.randbelow(37)
        is_win, coef = check_win(result_number, bet_type)

        if is_win:
            payout = (amount * coef).quantize(Decimal("0.01"), rounding=ROUND_DOWN)
            balances[user_id] += payout
            profit = payout - amount

            result_text = (
                "✅ <b>Победа!</b>\n"
                f"🎡 Выпало: <b>{result_number}</b> — {get_number_info(result_number)}\n"
                f"💸 Ставка: <b>{money(amount)}</b>\n"
                f"📈 Коэффициент: <b>x{coef}</b>\n"
                f"🏆 Выплата: <b>{money(payout)}</b>\n"
                f"➕ Чистый выигрыш: <b>{money(profit)}</b>\n"
                f"💰 Баланс: <b>{money(balances[user_id])}</b>"
            )
        else:
            result_text = (
                "❌ <b>Проигрыш.</b>\n"
                f"🎡 Выпало: <b>{result_number}</b> — {get_number_info(result_number)}\n"
                f"💸 Ставка: <b>{money(amount)}</b>\n"
                f"💰 Баланс: <b>{money(balances[user_id])}</b>"
            )

    await message.answer(result_text)


@dp.message()
async def unknown_handler(message: Message):
    await message.answer(
        "Напиши ставку так:\n"
        "<code>рул 100 к</code>\n\n"
        "Или посмотри баланс:\n"
        "<code>баланс</code>"
    )


async def main():
    if not TOKEN:
        raise RuntimeError("Укажи токен в переменной окружения BOT_TOKEN")

    bot = Bot(token=TOKEN, parse_mode="HTML")
    await dp.start_polling(bot)


if __name__ == "__main__":
    asyncio.run(main())

Как запустить:

bash
export BOT_TOKEN="твой_токен_бота"
python bot.py

Важно: баланс тут хранится в памяти, поэтому после перезапуска бота всё сбросится. Для нормального проекта следующий шаг — перенести balances в SQLite.