Загрузка...

Script
Bot guarantor GameFrogEscrow

Thread in Python created by LaylaSX Feb 5, 2026. 180 views

  1. LaylaSX
    LaylaSX Topic starter Feb 5, 2026 0 Jan 30, 2026
    Python
    # ============================================
    # GAMEFROG ESCROW BOT FINAL v2
    # ============================================
    # pip install aiogram3
    # ============================================

    import asyncio
    import json
    import uuid
    import os
    from datetime import datetime
    from aiogram import Bot, Dispatcher, F
    from aiogram.types import Message, InlineKeyboardButton, InlineKeyboardMarkup, CallbackQuery, BotCommand
    from aiogram.filters import Command, CommandStart, CommandObject
    from aiogram.fsm.context import FSMContext
    from aiogram.fsm.state import StatesGroup, State

    # ═══════════════════════════════════════════════════════════════
    # КОНФИГУРАЦИЯ
    # ═══════════════════════════════════════════════════════
    BOT_TOKEN = ""
    ADMIN_ID = ""
    USDT_ADDRESS = ""
    FEE_PERCENT = 0.05
    SUPPORT_LINK = ""

    DEALS_FILE = "deals.json"
    USERS_FILE = "users.json"

    # ═══════════════════════════════════════════════════════════════
    # ЭМОДЗИ
    # ═══════════════════════════════════════════════════════════════
    E = {
    "frog": "", "money": "", "shield": "", "check": "",
    "cross": "", "warn": "", "party": "", "seller": "",
    "buyer": "", "clock": "", "box": "", "dispute": "",
    "back": "", "star": "", "link": "", "cart": "",
    "new": "", "search": "", "help": "", "memo": "",
    "send": "", "refund": "", "done": ""
    }

    # ═══════════════════════════════════════════════════════════════
    # СОСТОЯНИЯ
    # ═══════════════════════════════════════════════════════════════
    class FrogState(StatesGroup):
    buyer_title = State()
    buyer_amount = State()
    seller_code = State()
    seller_account = State()
    dispute_reason = State()

    # ═══════════════════════════════════════════════════════════════
    # ИНСТРУМЕНТЫ ДАННЫХ
    # ═══════════════════════════════════════════════════════════════
    def load_json(filename):
    try:
    if not os.path.exists(filename):
    return {}
    with open(filename, 'r', encoding='utf-8') as f:
    return json.load(f)
    except:
    return {}

    def save_json(filename, data):
    with open(filename, 'w', encoding='utf-8') as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

    def get_deal(code):
    deals = load_json(DEALS_FILE)
    return deals.get(code.upper())

    def save_deal(code, data):
    deals = load_json(DEALS_FILE)
    deals[code.upper()] = data
    save_json(DEALS_FILE, deals)

    def get_user(user_id):
    users = load_json(USERS_FILE)
    return users.get(str(user_id))

    def save_user(user_id, data):
    users = load_json(USERS_FILE)
    users[str(user_id)] = data
    save_json(USERS_FILE, users)

    def generate_code():
    return str(uuid.uuid4())[:8].upper()

    # ═══════════════════════════════════════════════════════════════
    # КЛАВИАТУРЫ
    # ═══════════════════════════════════════════════════════════════
    def main_kb():
    return InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['buyer']} Купить", callback_data="role_buyer"),
    InlineKeyboardButton(text=f"{E['seller']} Продать", callback_data="role_seller")],
    [InlineKeyboardButton(text=f"{E['star']} Профиль", callback_data="my_profile")],
    [InlineKeyboardButton(text=f"{E['shield']} Помощь", callback_data="help")]
    ])

    def buyer_menu_kb():
    return InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['new']} Создать сделку", callback_data="new_deal")],
    [InlineKeyboardButton(text=f"{E['back']} Назад", callback_data="back_main")]
    ])

    def seller_menu_kb():
    return InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['search']} Присоединиться", callback_data="join_deal")],
    [InlineKeyboardButton(text=f"{E['back']} Назад", callback_data="back_main")]
    ])

    def help_kb():
    return InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['memo']} Как это работает", callback_data="how_it_works")],
    [InlineKeyboardButton(text=f"{E['shield']} Безопасность", callback_data="guarantees")],
    [InlineKeyboardButton(text=f"{E['frog']} О боте", callback_data="about")],
    [InlineKeyboardButton(text=f"{E['back']} Назад", callback_data="back_main")]
    ])

    def profile_kb():
    return InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['link']} Реферальная ссылка", callback_data="referral")],
    [InlineKeyboardButton(text=f"{E['back']} Назад", callback_data="back_main")]
    ])

    def admin_kb(code):
    return InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['refund']} Возврат", callback_data=f"admin_refund:{code}")],
    [InlineKeyboardButton(text=f"{E['money']} Оплата", callback_data=f"admin_pay:{code}")]
    ])

    # ═══════════════════════════════════════════════════════════════
    # БОТ
    # ═══════════════════════════════════════════════════════════════
    bot = Bot(token=BOT_TOKEN)
    dp = Dispatcher()

    async def set_commands():
    await bot.set_my_commands([
    BotCommand(command="start", description="Перезапустить бота"),
    ])

    # ═══════════════════════════════════════════════════════════════
    # /START с рефералами
    # ═══════════════════════════════════════════════════════════════
    @dp.message(CommandStart())
    async def cmd_start(message: Message, command: CommandObject):
    users = load_json(USERS_FILE)
    uid = str(message.from_user.id)

    # Парсим реферальный код
    ref = command.args if command.args and command.args != uid else None

    # Регистрация
    if uid not in users:
    users[uid] = {
    "name": message.from_user.full_name,
    "username": message.from_user.username,
    "deals_count": 0,
    "ref_count": 0,
    "referred_by": ref,
    "joined": datetime.now().strftime("%d.%m.%Y")
    }
    # Бонус рефереру
    if ref and ref in users:
    users[ref]["ref_count"] = users[ref].get("ref_count", 0) + 1

    # Защита от KeyError
    if "deals_count" not in users[uid]:
    users[uid]["deals_count"] = 0
    if "ref_count" not in users[uid]:
    users[uid]["ref_count"] = 0

    save_json(USERS_FILE, users)

    await message.answer(
    f"{E['frog']} <b>GameFrog Escrow</b>\n"
    f"{E['shield']} Безопасные сделки с гарантией\n\n"
    f"<b>Привет, {message.from_user.first_name}!</b>\n\n"
    f"Добро пожаловать в сервис безопасных сделок!\n\n"
    f"Здесь вы можете:\n"
    f"• <b>Купить</b> — создавать заказы с защитой денег\n"
    f"• <b>Продать</b> — принимать заказы с гарантией оплаты\n"
    f"• <b>Спокойствие</b> — деньги у гаранта до завершения\n\n"
    f"Выберите действие:",
    reply_markup=main_kb(),
    parse_mode="HTML"
    )

    # ═══════════════════════════════════════════════════════════════
    # ГЛАВНОЕ МЕНЮ
    # ═══════════════════════════════════════════════════════════════
    @dp.callback_query(F.data == "back_main")
    async def back_main(callback: CallbackQuery):
    await callback.message.edit_text(
    f"{E['frog']} <b>GameFrog Escrow</b>\n"
    f"{E['shield']} Безопасные сделки с гарантией\n\n"
    f"Выберите действие:",
    reply_markup=main_kb(),
    parse_mode="HTML"
    )
    await callback.answer()

    # ═══════════════════════════════════════════════════════════════
    # РОЛЬ - ПОКУПАТЕЛЬ
    # ═══════════════════════════════════════════════════════════════
    @dp.callback_query(F.data == "role_buyer")
    async def role_buyer(callback: CallbackQuery):
    await callback.message.edit_text(
    f"{E['buyer']} <b>Режим покупателя</b>\n\n"
    f"Создавайте сделки и безопасно оплачивайте.\n"
    f"Средства у гаранта до подтверждения.\n\n"
    f"{E['new']} <b>Создать сделку</b>\n"
    f"{E['cart']} <b></b>",
    reply_markup=buyer_menu_kb(),
    parse_mode="HTML"
    )
    await callback.answer()

    # ═══════════════════════════════════════════════════════════════
    # РОЛЬ - ПРОДАВЕЦ
    # ═══════════════════════════════════════════════════════════════
    @dp.callback_query(F.data == "role_seller")
    async def role_seller(callback: CallbackQuery):
    await callback.message.edit_text(
    f"{E['seller']} <b>Режим продавца</b>\n\n"
    f"Принимайте заказы и безопасно получайте оплату.\n\n"
    f"{E['search']} <b>Присоединиться</b>\n"
    f"{E['cart']} <b></b>",
    reply_markup=seller_menu_kb(),
    parse_mode="HTML"
    )
    await callback.answer()

    # ═══════════════════════════════════════════════════════════════
    # ПОМОЩЬ
    # ═══════════════════════════════════════════════════════════════
    @dp.callback_query(F.data == "help")
    async def help_menu(callback: CallbackQuery):
    text = (
    f"{E['shield']} <b>ВСЕ О GAMEFROG ESCROW</b>\n\n"
    f"<b> ЧТО ЭТО?</b>\n"
    f"GameFrog — это надежный сервис для безопасных сделок.\n"
    f"Мы гарантируем, что деньги защищены до конца сделки.\n\n"
    f"<b> КАК ЭТО РАБОТАЕТ?</b>\n"
    f"1. Покупатель создает сделку → получает уникальный код\n"
    f"2. Покупатель отправляет USDT на адрес гаранта\n"
    f"3. Продавец видит код → присоединяется к сделке\n"
    f"4. Продавец отправляет товар/услугу\n"
    f"5. Покупатель проверяет → подтверждает получение\n"
    f"6. Деньги (минус 5% комиссия) идут продавцу\n\n"
    f"<b> ГАРАНТИИ БЕЗОПАСНОСТИ</b>\n"
    f"<b>Для покупателя:</b>\n"
    f"✓ Деньги заморожены у гаранта\n"
    f"✓ Продавец получает только после вашего подтверждения\n"
    f"✓ Можете открыть спор если товар не соответствует\n\n"
    f"<b>Для продавца:</b>\n"
    f"✓ Гарантия оплаты за отправку\n"
    f"✓ Защита от неоплаты и отмены\n"
    f"✓ Прозрачная система без скрытых платежей\n\n"
    f"<b> КОМИССИЯ</b>\n"
    f"Всего 5% от суммы сделки. Прозрачно и честно.\n\n"
    f"<b> ЧТО ПРИ СПОРЕ?</b>\n"
    f"Если возник конфликт, администратор разберет ситуацию\n"
    f"и вернет деньги покупателю или выплатит продавцу.\n\n"
    f"<b> ОСНОВНЫЕ ПРАВИЛА</b>\n"
    f"• Внимательно проверяйте товар перед подтверждением\n"
    f"• Сохраняйте доказательства (скрины, фото)\n"
    f"• Будьте честны и вежливы\n"
    f"• При проблемах звоните админу\n\n"
    f"<b>Вопросы? Пишите в поддержку!</b>"
    )
    kb = InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f" Как создать сделку", callback_data="how_it_works")],
    [InlineKeyboardButton(text=f" Связь с админом", url=SUPPORT_LINK)],
    [InlineKeyboardButton(text=f"{E['back']} Назад", callback_data="back_main")]
    ])
    await callback.message.edit_text(text, reply_markup=kb, parse_mode="HTML")
    await callback.answer()

    @dp.callback_query(F.data == "how_it_works")
    async def how_it_works(callback: CallbackQuery):
    await callback.message.edit_text(
    f"{E['memo']} <b>Как это работает</b>\n\n"
    f"1. Покупатель создаёт сделку → получает код\n"
    f"2. Покупатель оплачивает на гарант-адрес\n"
    f"3. Продавец вводит код → принимает сделку\n"
    f"4. Продавец отправляет товар\n"
    f"5. Покупатель подтверждает → деньги уходят\n\n"
    f"{E['done']} Сделка завершена!",
    reply_markup=help_kb(),
    parse_mode="HTML"
    )
    await callback.answer()

    @dp.callback_query(F.data == "guarantees")
    async def guarantees(callback: CallbackQuery):
    await callback.message.edit_text(
    f"{E['shield']} <b>Гарантии</b>\n\n"
    f"{E['check']} <b>Для покупателя:</b>\n"
    f"- Деньги у гаранта до подтверждения\n"
    f"- Продавец получает только после проверки\n"
    f"- Возможность открыть спор\n\n"
    f"{E['check']} <b>Для продавца:</b>\n"
    f"- Гарантия оплаты после отправки\n"
    f"- Нет риска неоплаты\n\n"
    f"{E['warn']} Внимательно проверяйте товар!",
    reply_markup=help_kb(),
    parse_mode="HTML"
    )
    await callback.answer()

    @dp.callback_query(F.data == "about")
    async def about_bot(callback: CallbackQuery):
    await callback.message.edit_text(
    f"{E['frog']} <b>GameFrog Escrow</b>\n\n"
    f"Бот-гарант для безопасных сделок.\n\n"
    f"- Создание сделок за 30 секунд\n"
    f"- Поддержка USDT (TRC20)\n"
    f"- Система кодов сделок\n"
    f"- Разрешение споров\n"
    f"- Комиссия 5%\n\n"
    f"{E['frog']} Сделано с любовью!",
    reply_markup=help_kb(),
    parse_mode="HTML"
    )
    await callback.answer()

    # ═══════════════════════════════════════════════════════════════
    # ПРОФИЛЬ
    # ═══════════════════════════════════════════════════════════════
    @dp.callback_query(F.data == "my_profile")
    async def my_profile(callback: CallbackQuery):
    u = load_json(USERS_FILE).get(str(callback.from_user.id), {})
    text = (
    f"{E['star']} <b>Ваш профиль:</b>\n\n"
    f"Имя: {u.get('name', 'Неизвестно')}\n"
    f"Сделок: {u.get('deals_count', 0)}\n"
    f"Рефералов: {u.get('ref_count', 0)}\n"
    f"Регистрация: {u.get('joined', 'Неизвестно')}"
    )
    await callback.message.edit_text(text, reply_markup=profile_kb(), parse_mode="HTML")
    await callback.answer()

    @dp.callback_query(F.data == "referral")
    async def referral(callback: CallbackQuery):
    me = await bot.get_me()
    u = load_json(USERS_FILE).get(str(callback.from_user.id), {})
    link = f"https://t.me/{me.username}?start={callback.from_user.id}"
    text = (
    f"{E['link']} <b>Ваша реферальная ссылка:</b>\n\n"
    f"<code>{link}</code>\n\n"
    f"Приглашено: {u.get('ref_count', 0)}"
    )
    await callback.message.edit_text(text, reply_markup=profile_kb(), parse_mode="HTML")
    await callback.answer()

    # ═══════════════════════════════════════════════════════════════
    # СОЗДАНИЕ СДЕЛКИ
    # ═══════════════════════════════════════════════════════════════
    @dp.callback_query(F.data == "new_deal")
    async def new_deal(callback: CallbackQuery, state: FSMContext):
    await callback.message.edit_text(
    f"{E['new']} <b>Новая сделка</b>\n\n"
    f"Введите название товара/услуги:",
    reply_markup=InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['back']} Отмена", callback_data="role_buyer")]
    ]),
    parse_mode="HTML"
    )
    await state.set_state(FrogState.buyer_title)
    await callback.answer()

    @dp.message(FrogState.buyer_title)
    async def buyer_title(message: Message, state: FSMContext):
    if len(message.text) > 100:
    await message.answer(f"{E['warn']} Максимум 100 символов")
    return
    await state.update_data(title=message.text)
    await message.answer(
    f"{E['money']} <b>Сумма сделки</b>\n\n"
    f"Введите сумму в USDT:",
    reply_markup=InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['back']} Назад", callback_data="new_deal")]
    ]),
    parse_mode="HTML"
    )
    await state.set_state(FrogState.buyer_amount)

    @dp.message(FrogState.buyer_amount)
    async def buyer_amount(message: Message, state: FSMContext):
    try:
    amount = float(message.text.replace(',', '.'))
    if amount < 1:
    raise ValueError()
    except:
    await message.answer(f"{E['warn']} Минимум 1 USDT")
    return

    data = await state.get_data()
    user_id = str(message.from_user.id)
    user = get_user(user_id)

    code = generate_code()
    deal = {
    "code": code,
    "title": data["title"],
    "amount": amount,
    "usdt_address": USDT_ADDRESS,
    "buyer_id": user_id,
    "buyer_name": user["name"] if user else "Покупатель",
    "seller_id": None,
    "seller_name": None,
    "seller_account": None,
    "status": "created",
    "created_at": datetime.now().isoformat()
    }
    save_deal(code, deal)

    user["deals_count"] = user.get("deals_count", 0) + 1
    save_user(user_id, user)

    await message.answer(
    f"{E['check']} <b>Сделка #{code} создана!</b>\n\n"
    f"{E['cart']} <b>{data['title']}</b>\n"
    f"{E['money']} <b>Сумма: {amount} USDT</b>\n\n"
    f"1. Переведите <b>{amount} USDT</b> на:\n"
    f"<code>{USDT_ADDRESS}</code>\n\n"
    f"2. Код сделки: <b>{code}</b>\n"
    f"Отправьте этот код продавцу",
    reply_markup=InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['money']} Я оплатил", callback_data=f"paid:{code}")],
    [InlineKeyboardButton(text=f"{E['cross']} Отменить", callback_data=f"cancel:{code}")]
    ]),
    parse_mode="HTML"
    )
    await state.clear()

    # ═══════════════════════════════════════════════════════════════
    # ПРИСОЕДИНЕНИЕ
    # ═══════════════════════════════════════════════════════════════
    @dp.callback_query(F.data == "join_deal")
    async def join_deal(callback: CallbackQuery, state: FSMContext):
    await callback.message.edit_text(
    f"{E['search']} Присоединение к сделке\n\n"
    f"Введите код сделки:",
    reply_markup=InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['back']} Назад", callback_data="role_seller")]
    ]),
    parse_mode="HTML"
    )
    await state.set_state(FrogState.seller_code)
    await callback.answer()

    @dp.message(FrogState.seller_code)
    async def seller_code(message: Message, state: FSMContext):
    code = message.text.strip().upper()
    deal = get_deal(code)

    if not deal:
    await message.answer(
    f"{E['cross']} Сделка не найдена!",
    reply_markup=seller_menu_kb()
    )
    return

    user_id = str(message.from_user.id)

    if deal["buyer_id"] == user_id:
    await message.answer(
    f"{E['warn']} Ошибка!\n\n"
    f"Вы не можете быть продавцом в своей сделке.",
    reply_markup=seller_menu_kb()
    )
    return

    if deal["seller_id"]:
    await message.answer(
    f"{E['warn']} Сделка уже принята!",
    reply_markup=seller_menu_kb()
    )
    return

    await state.update_data(deal_code=code)
    await message.answer(
    f"{E['check']} <b>Сделка #{code}</b>\n\n"
    f"{E['cart']} {deal['title']}\n"
    f"{E['money']} <b>{deal['amount']} USDT</b>\n\n"
    f"Введите реквизиты для получения оплаты:",
    reply_markup=InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['back']} Назад", callback_data="join_deal")]
    ]),
    parse_mode="HTML"
    )
    await state.set_state(FrogState.seller_account)

    @dp.message(FrogState.seller_account)
    async def seller_account(message: Message, state: FSMContext):
    data = await state.get_data()
    code = data["deal_code"]
    deal = get_deal(code)

    if not deal:
    await message.answer(f"{E['cross']} Сделка не найдена")
    return

    user_id = str(message.from_user.id)
    user = get_user(user_id)

    deal["seller_id"] = user_id
    deal["seller_name"] = user["name"] if user else "Продавец"
    deal["seller_account"] = message.text
    deal["status"] = "paid"
    deal["paid_at"] = datetime.now().isoformat()
    save_deal(code, deal)

    user["deals_count"] = user.get("deals_count", 0) + 1
    save_user(user_id, user)

    kb = InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['send']} Товар отправлен", callback_data=f"send:{code}")],
    [InlineKeyboardButton(text=f"{E['back']} Назад", callback_data="role_seller")]
    ])

    await message.answer(
    f"{E['frog']} <b>Вы приняли сделку #{code}!</b>\n\n"
    f"{E['clock']} Ожидаем оплату от покупателя.\n"
    f"{E['money']} Деньги придут на:\n"
    f"<code>{message.text}</code>",
    reply_markup=kb,
    parse_mode="HTML"
    )

    try:
    await bot.send_message(
    int(deal["buyer_id"]),
    f"{E['frog']} Продавец принял сделку!\n\n"
    f"Можно оплачивать."
    )
    except:
    pass

    await state.clear()

    # ═══════════════════════════════════════════════════════════════
    # ОПЛАТА
    # ═══════════════════════════════════════════════════════════════
    @dp.callback_query(F.data.startswith("paid:"))
    async def paid_callback(callback: CallbackQuery):
    code = callback.data.split(":")[1]
    deal = get_deal(code)

    if not deal:
    await callback.answer("Сделка не найдена")
    return

    deal["status"] = "sent"
    deal["sent_at"] = datetime.now().isoformat()
    save_deal(code, deal)

    kb = InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['check']} Товар получен", callback_data=f"confirm:{code}")],
    [InlineKeyboardButton(text=f"{E['dispute']} Спор", callback_data=f"dispute:{code}")]
    ])

    await callback.message.edit_text(
    f"{E['money']} <b>Оплата подтверждена!</b>\n\n"
    f"{E['frog']} Деньги у гаранта.\n"
    f"{E['seller']} Продавец получит уведомление.",
    reply_markup=kb,
    parse_mode="HTML"
    )

    if deal["seller_id"]:
    try:
    await bot.send_message(
    int(deal["seller_id"]),
    f"{E['money']} Покупатель оплатил!\n\n"
    f"{E['send']} Отправьте товар покупателю."
    )
    except:
    pass

    await callback.answer()

    # ═══════════════════════════════════════════════════════════════
    # ОТПРАВКА ТОВАРА
    # ═══════════════════════════════════════════════════════════════
    @dp.callback_query(F.data.startswith("send:"))
    async def send_callback(callback: CallbackQuery):
    code = callback.data.split(":")[1]
    deal = get_deal(code)

    if not deal:
    await callback.answer("Сделка не найдена")
    return

    deal["status"] = "goods_sent"
    deal["goods_sent_at"] = datetime.now().isoformat()
    save_deal(code, deal)

    kb = InlineKeyboardMarkup(inline_keyboard=[
    [InlineKeyboardButton(text=f"{E['check']} Товар получен", callback_data=f"confirm:{code}")],
    [InlineKeyboardButton(text=f"{E['dispute']} Спор", callback_data=f"dispute:{code}")]
    ])

    await callback.message.edit_text(
    f"{E['send']} <b>Товар отправлен!</b>\n\n"
    f"{E['buyer']} Покупатель проверит и подтвердит.",
    reply_markup=kb,
    parse_mode="HTML"
    )

    try:
    await bot.send_message(
    int(deal["buyer_id"]),
    f"{E['send']} <b>Продавец отправил товар!</b>\n\n"
    f"{E['check']} Проверьте и подтвердите получение.",
    reply_markup=kb
    )
    except:
    pass

    await callback.answer()

    # ═══════════════════════════════════════════════════════════════
    # ПОДТВЕРЖДЕНИЕ
    # ═══════════════════════════════════════════════════════════════
    @dp.callback_query(F.data.startswith("confirm:"))
    async def confirm_callback(callback: CallbackQuery):
    code = callback.data.split(":")[1]
    deal = get_deal(code)

    if not deal:
    await callback.answer("Сделка не найдена")
    return

    fee = deal["amount"] * FEE_PERCENT
    seller_gets = deal["amount"] - fee

    deal["status"] = "completed"
    deal["completed_at"] = datetime.now().isoformat()
    save_deal(code, deal)

    await callback.message.edit_text(
    f"{E['party']} <b>Сделка #{code} завершена!</b>\n\n"
    f"{E['cart']} {deal['title']}\n"
    f"{E['money']} Сумма: {deal['amount']} USDT\n"
    f"Комиссия (5%): {fee:.2f} USDT\n\n"
    f"{E['seller']} Продавец получит: <b>{seller_gets:.2f} USDT</b>\n"
    f"На: <code>{deal['seller_account']}</code>\n\n"
    f"{E['done']} Спасибо за использование GameFrog!",
    parse_mode="HTML"
    )

    if deal["seller_id"]:
    try:
    await bot.send_message(
    int(deal["seller_id"]),
    f"{E['party']} <b>Сделка завершена!</b>\n\n"
    f"{E['money']} Вы получите {seller_gets:.2f} USDT"
    )
    except:
    pass

    await callback.answer()

    # ═══════════════════════════════════════════════════════════════
    # СПОР
    # ═══════════════════════════════════════════════════════════════
    @dp.callback_query(F.data.startswith("dispute:"))
    async def dispute_callback(callback: CallbackQuery, state: FSMContext):
    code = callback.data.split(":")[1]
    await callback.message.edit_text(
    f"{E['dispute']} <b>Открытие спора</b>\n\n"
    f"Опишите проблему:",
    parse_mode="HTML"
    )
    await state.update_data(deal_code=code)
    await state.set_state(FrogState.dispute_reason)
    await callback.answer()

    @dp.message(FrogState.dispute_reason)
    async def dispute_reason(message: Message, state: FSMContext):
    data = await state.get_data()
    code = data["deal_code"]
    deal = get_deal(code)

    if not deal:
    await message.answer("Сделка не найдена")
    return

    deal["dispute"] = message.text
    deal["dispute_opened_at"] = datetime.now().isoformat()
    save_deal(code, deal)

    await message
     
Loading...