Загрузка...

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
     
    Feb 5, 2026
Loading...