bitcoin_bot.py

# bot.py
import asyncio
import sqlite3
import logging
from datetime import datetime, timedelta
from aiogram import Bot, Dispatcher, types
from aiogram import F
from aiogram.filters import Command
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup
from embit import transaction, script, ec, networks
from embit.networks import NETWORKS
import pyotp
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
import base64
import hashlib
import os
from PIL import Image
from pyzbar.pyzbar import decode
import qrcode
import io
import cv2
from qreader import QReader
# Импортируем наш собственный URDecoder и локализацию
# from ur import URDecoder # Закомментировано, так как мы используем собственный
import cbor2
from localization import get_text, get_user_language, LANGUAGES

# === Альтернативный URDecoder ===
class URDecoder:
    def __init__(self):
        self._parts = {}
        self._expected_count = None
        self._expected_digest = None
        self._result_data = None
        self._is_complete_flag = False
        self._error = None

    def receive(self, ur_string):
        if self._is_complete_flag:
            return
        if self._error:
            return

        try:
            if not ur_string.lower().startswith("ur:"):
                self._error = "Неверный формат UR: не начинается с 'ur:'"
                return

            parts = ur_string[3:].split("/")
            if len(parts) < 3:
                self._error = "Неверный формат UR: недостаточно частей"
                return

            type_and_id = parts[0]
            indices_part = parts[1]
            data_part = "/".join(parts[2:])

            indices = indices_part.split("-")
            if len(indices) != 2:
                self._error = "Неверный формат индексов"
                return
            
            index = int(indices[0])
            total_count = int(indices[1])

            if self._expected_count is None:
                self._expected_count = total_count
            elif self._expected_count != total_count:
                self._error = "Несовпадение общего количества частей"
                return

            try:
                decoded_data_part = base64.b64decode(data_part, validate=True)
            except Exception:
                decoded_data_part = data_part.encode('utf-8')

            if index == 1:
                try:
                    cbor_data = cbor2.loads(decoded_data_part)
                    if isinstance(cbor_data, list) and len(cbor_data) >= 3:
                        self._expected_digest = cbor_data[1]
                        first_chunk = cbor_data[2]
                        self._parts[1] = first_chunk
                    else:
                        self._parts[1] = decoded_data_part
                except Exception:
                    self._parts[1] = decoded_data_part
            else:
                self._parts[index] = decoded_data_part

            if len(self._parts) == self._expected_count:
                sorted_parts = [self._parts[i] for i in sorted(self._parts.keys())]
                combined_data = b''.join(sorted_parts)
                
                if self._expected_digest:
                    import hashlib
                    calculated_digest = hashlib.sha256(combined_data).digest()
                    if calculated_digest != self._expected_digest:
                        self._error = "Несовпадение контрольной суммы данных"
                        return

                self._result_data = combined_data
                self._is_complete_flag = True

        except ValueError as e:
            self._error = f"Ошибка преобразования числа: {e}"
        except Exception as e:
            self._error = f"Ошибка обработки UR: {e}"

    def is_complete(self):
        return self._is_complete_flag

    def result(self):
        if not self._is_complete_flag:
            raise ValueError("Сборка не завершена")
        if self._error:
            raise ValueError(f"Ошибка сборки: {self._error}")
        
        class ResultWrapper:
            def __init__(self, data_bytes):
                self._data = data_bytes
            def decode(self):
                return base64.b64encode(self._data).decode('utf-8')
        
        return ResultWrapper(self._result_data)

    def is_error(self):
        return self._error is not None

    def error(self):
        return self._error
# === Конец альтернативного URDecoder ===

# Глобальная конфигурация
TELEGRAM_TOKEN = "TELEGRAM_TOKENXfbVu4aCE3z_DMeao"  # Замени на свой токен
DB_PATH = "config.db"
MAX_2FA_ATTEMPTS = 3
BLOCK_DURATION = 600  # 10 минут блокировки
NETWORK = NETWORKS["main"]  # Используем основную сеть Bitcoin

# Настройка логирования
logging.basicConfig(filename='bot.log', level=logging.INFO, 
                    format='%(asctime)s - %(levelname)s - %(message)s')

# Определение состояний FSM
class TransactionStates(StatesGroup):
    await_2fa = State()
    await_password = State()

# Новые состояния для мастеров
class AddWalletStates(StatesGroup):
    waiting_for_pubkey1 = State()
    waiting_for_pubkey2 = State()
    waiting_for_pubkey3 = State()
    waiting_for_encrypted_key = State()

class SetLimitsStates(StatesGroup):
    waiting_for_wallet_id = State()
    waiting_for_monthly_limit = State()
    waiting_for_min_fee = State()
    waiting_for_max_fee = State()

class WhitelistStates(StatesGroup):
    waiting_for_wallet_id_for_add = State()
    waiting_for_address_to_add = State()
    waiting_for_wallet_id_for_remove = State()
    waiting_for_address_to_remove = State()

class SignTransactionStates(StatesGroup):
    waiting_for_wallet_selection = State()
    # Остальные состояния остаются в TransactionStates

# Инициализация базы данных
def init_db():
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("""CREATE TABLE IF NOT EXISTS users (
        user_id INTEGER PRIMARY KEY,
        totp_secret TEXT
    )""")
    c.execute("""CREATE TABLE IF NOT EXISTS wallets (
        user_id INTEGER,
        wallet_id INTEGER,
        multisig_pubkeys TEXT,
        encrypted_key TEXT,
        monthly_limit_btc REAL DEFAULT 0.01,
        min_fee_btc REAL DEFAULT 0.0001,
        max_fee_btc REAL DEFAULT 0.001,
        PRIMARY KEY (user_id, wallet_id)
    )""")
    c.execute("""CREATE TABLE IF NOT EXISTS whitelist (
        user_id INTEGER,
        wallet_id INTEGER,
        address TEXT,
        PRIMARY KEY (user_id, wallet_id, address)
    )""")
    c.execute("""CREATE TABLE IF NOT EXISTS transactions (
        user_id INTEGER,
        wallet_id INTEGER,
        timestamp TEXT,
        amount_btc REAL
    )""")
    c.execute("""CREATE TABLE IF NOT EXISTS config (
        key TEXT PRIMARY KEY,
        value TEXT
    )""")
    c.execute("INSERT OR IGNORE INTO config (key, value) VALUES (?, ?)",
              ("failed_attempts", "{}"))
    c.execute("INSERT OR IGNORE INTO config (key, value) VALUES (?, ?)",
              ("block_until", "{}"))
    c.execute("SELECT name FROM sqlite_master WHERE type='table';")
    tables = c.fetchall()
    logging.info(f"Database tables created: {tables}")
    conn.commit()
    conn.close()

# Проверка регистрации пользователя
def is_registered(user_id):
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("SELECT 1 FROM users WHERE user_id = ?", (user_id,))
    result = c.fetchone()
    conn.close()
    return bool(result)

# Проверка существования кошелька
def wallet_exists(user_id, wallet_id):
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("SELECT 1 FROM wallets WHERE user_id = ? AND wallet_id = ?", (user_id, wallet_id))
    result = c.fetchone()
    conn.close()
    return bool(result)

# Получить список кошельков пользователя
def get_user_wallets(user_id):
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("SELECT wallet_id FROM wallets WHERE user_id = ?", (user_id,))
    wallets = c.fetchall()
    conn.close()
    return wallets

# Проверка месячного лимита
def check_monthly_limit(user_id, wallet_id, amount_btc):
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("SELECT monthly_limit_btc FROM wallets WHERE user_id = ? AND wallet_id = ?",
              (user_id, wallet_id))
    monthly_limit = c.fetchone()[0]
    month_ago = (datetime.now() - timedelta(days=30)).isoformat()
    c.execute("SELECT SUM(amount_btc) FROM transactions WHERE user_id = ? AND wallet_id = ? AND timestamp > ?",
              (user_id, wallet_id, month_ago))
    total = c.fetchone()[0] or 0
    conn.close()
    return total + amount_btc <= monthly_limit

# Проверка адреса сдачи
def check_change_address(address, pubkeys):
    try:
        pubkeys = [ec.PublicKey.parse(bytes.fromhex(pk)) for pk in pubkeys]
        multisig = script.ScriptMultisig(m=2, pubkeys=sorted(pubkeys, key=lambda x: x.serialize()))
        p2wsh = script.p2wsh(multisig)
        expected_address = p2wsh.address(NETWORK)
        return address == expected_address
    except Exception as e:
        logging.error(f"Error checking change address: {str(e)}")
        return False

# Шифрование и расшифровка ключа
def encrypt_key(private_key, password):
    key = hashlib.sha256(password.encode()).digest()
    cipher = AES.new(key, AES.MODE_EAX)
    nonce = cipher.nonce
    ciphertext, tag = cipher.encrypt_and_digest(private_key.encode())
    return base64.b64encode(nonce + tag + ciphertext).decode()

def decrypt_key(encrypted_key, password):
    key = hashlib.sha256(password.encode()).digest()
    data = base64.b64decode(encrypted_key)
    nonce, tag, ciphertext = data[:16], data[16:32], data[32:]
    cipher = AES.new(key, AES.MODE_EAX, nonce=nonce)
    return cipher.decrypt_and_verify(ciphertext, tag).decode()

# Управление белым списком
def add_address(user_id, wallet_id, address):
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("INSERT OR IGNORE INTO whitelist (user_id, wallet_id, address) VALUES (?, ?, ?)",
              (user_id, wallet_id, address))
    conn.commit()
    conn.close()
    return address

def remove_address(user_id, wallet_id, address):
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("DELETE FROM whitelist WHERE user_id = ? AND wallet_id = ? AND address = ?",
              (user_id, wallet_id, address))
    conn.commit()
    conn.close()
    return address

def get_whitelist(user_id, wallet_id):
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("SELECT address FROM whitelist WHERE user_id = ? AND wallet_id = ?",
              (user_id, wallet_id))
    addresses = {row[0] for row in c.fetchall()}
    conn.close()
    return addresses

# Проверка блокировки 2FA
def check_blocked(user_id):
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("SELECT value FROM config WHERE key = 'block_until'")
    block_until = eval(c.fetchone()[0])
    conn.close()
    return block_until.get(str(user_id), 0) > datetime.now().timestamp()

def update_attempts(user_id, failed_attempts):
    conn = sqlite3.connect(DB_PATH)
    c = conn.cursor()
    c.execute("SELECT value FROM config WHERE key = 'failed_attempts'")
    attempts = eval(c.fetchone()[0])
    attempts[str(user_id)] = failed_attempts
    c.execute("UPDATE config SET value = ? WHERE key = 'failed_attempts'", (str(attempts),))
    if failed_attempts >= MAX_2FA_ATTEMPTS:
        block_until = eval(c.execute("SELECT value FROM config WHERE key = 'block_until'").fetchone()[0])
        block_until[str(user_id)] = (datetime.now() + timedelta(seconds=BLOCK_DURATION)).timestamp()
        c.execute("UPDATE config SET value = ? WHERE key = 'block_until'", (str(block_until),))
    conn.commit()
    conn.close()

# Функция для декодирования статического QR-кода
def extract_psbt_from_qr(image_bytes):
    try:
        image = Image.open(io.BytesIO(image_bytes))
        decoded_objects = decode(image)
        if not decoded_objects:
            return None, "QR-код не найден"
        psbt_data = decoded_objects[0].data.decode('utf-8')
        return psbt_data, None
    except Exception as e:
        return None, f"Ошибка декодирования QR-кода: {str(e)}"

# Функция для создания QR-кода
def create_qr_code(data):
    qr = qrcode.QRCode(version=1, error_correction=qrcode.constants.ERROR_CORRECT_L, box_size=10, border=4)
    qr.add_data(data)
    qr.make(fit=True)
    img = qr.make_image(fill_color="black", back_color="white")
    img_byte_arr = io.BytesIO()
    img.save(img_byte_arr, format='PNG')
    return img_byte_arr.getvalue()

# Инициализация бота
bot = Bot(token=TELEGRAM_TOKEN)
dp = Dispatcher()

# === УЛУЧШЕНИЯ ===

# Обработчик команды /start - с интерактивным меню и локализацией
@dp.message(Command("start"))
async def start_command(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    logging.info(f"Received /start command from user {user_id} (lang: {user_lang}), chat type: {message.chat.type}")

    # Создаем клавиатуру с локализованными кнопками
    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
        [types.InlineKeyboardButton(text=get_text('menu_register', user_lang), callback_data="menu_register")],
        [types.InlineKeyboardButton(text=get_text('menu_wallets', user_lang), callback_data="menu_wallets")],
        [types.InlineKeyboardButton(text=get_text('menu_sign', user_lang), callback_data="menu_sign")],
        [types.InlineKeyboardButton(text=get_text('menu_status', user_lang), callback_data="menu_status")],
        [types.InlineKeyboardButton(text=get_text('menu_help', user_lang), callback_data="menu_help")],
    ])

    welcome_text = get_text('start_message', user_lang)

    await message.answer(welcome_text, reply_markup=keyboard)
    logging.info(f"Sent start message with menu to user {user_id} (lang: {user_lang})")

# Обработчики кнопок главного меню
@dp.callback_query(F.data == "menu_register")
async def menu_register(callback: types.CallbackQuery):
    user_lang = get_user_language(callback.from_user)
    if is_registered(callback.from_user.id):
        await callback.answer(get_text('already_registered', user_lang))
        return
    await register_command(callback.message, dp.storage)
    await callback.answer()

@dp.callback_query(F.data == "menu_wallets")
async def menu_wallets(callback: types.CallbackQuery):
    user_id = callback.from_user.id
    user_lang = get_user_language(callback.from_user)
    if not is_registered(user_id):
        await callback.message.answer(get_text('not_registered', user_lang))
        await callback.answer()
        return

    # Создаем подменю для кошельков
    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
        [types.InlineKeyboardButton(text=get_text('wallet_add', user_lang), callback_data="wallet_add")],
        [types.InlineKeyboardButton(text=get_text('wallet_limits', user_lang), callback_data="wallet_limits")],
        [types.InlineKeyboardButton(text=get_text('wallet_whitelist', user_lang), callback_data="wallet_whitelist")],
        [types.InlineKeyboardButton(text=get_text('menu_back_to_main', user_lang), callback_data="menu_back_to_main")],
    ])
    await callback.message.edit_text(get_text('wallet_management', user_lang), reply_markup=keyboard)
    await callback.answer()

@dp.callback_query(F.data == "menu_sign")
async def menu_sign(callback: types.CallbackQuery, state: FSMContext):
    user_id = callback.from_user.id
    user_lang = get_user_language(callback.from_user)
    if not is_registered(user_id):
        await callback.message.answer(get_text('not_registered', user_lang))
        await callback.answer()
        return
    
    wallets = get_user_wallets(user_id)
    if not wallets:
        await callback.message.answer(get_text('no_wallets_yet', user_lang))
        await callback.answer()
        return
    
    # Создаем кнопки для выбора кошелька
    keyboard_buttons = []
    for wallet in wallets:
        wallet_id = wallet[0]
        # Простая локализация названия кнопки кошелька
        wallet_text = f"Кошелёк #{wallet_id}" if user_lang == 'ru' else f"Wallet #{wallet_id}"
        keyboard_buttons.append([types.InlineKeyboardButton(text=wallet_text, callback_data=f"sign_wallet_{wallet_id}")])
    keyboard_buttons.append([types.InlineKeyboardButton(text=get_text('menu_back_to_main', user_lang), callback_data="menu_back_to_main")])
    
    keyboard = types.InlineKeyboardMarkup(inline_keyboard=keyboard_buttons)
    sign_prompt = get_text('send_psbt', user_lang)
    await callback.message.edit_text(sign_prompt, reply_markup=keyboard)
    await callback.answer()

@dp.callback_query(F.data.startswith("sign_wallet_"))
async def sign_wallet_selected(callback: types.CallbackQuery, state: FSMContext):
    user_id = callback.from_user.id
    user_lang = get_user_language(callback.from_user)
    wallet_id = int(callback.data.split("_")[-1])
    
    await state.update_data(wallet_id=wallet_id)
    sign_prompt = get_text('send_psbt', user_lang)
    await callback.message.answer(sign_prompt)
    await callback.answer()

@dp.callback_query(F.data == "menu_status")
async def menu_status(callback: types.CallbackQuery):
    user_id = callback.from_user.id
    user_lang = get_user_language(callback.from_user)
    registered = is_registered(user_id)
    wallets = get_user_wallets(user_id)
    
    # Формируем сообщение статуса
    status_text_template = get_text('status_message', user_lang)
    # Простая замена плейсхолдеров
    registered_status_text = "Выполнена" if registered else "Не выполнена"
    registered_status_text_en = "Completed" if registered else "Not completed"
    
    if user_lang == 'ru':
        status_text = status_text_template.replace("{'✅' if registered else '❌'}", "✅" if registered else "❌")
        status_text = status_text.replace("{'Выполнена' if registered else 'Не выполнена'}", registered_status_text)
    elif user_lang == 'en':
        status_text = status_text_template.replace("{'✅' if registered else '❌'}", "✅" if registered else "❌")
        status_text = status_text.replace("{'Completed' if registered else 'Not completed'}", registered_status_text_en)
    else:
        # Для других языков используем английский вариант по умолчанию
        status_text = status_text_template.replace("{'✅' if registered else '❌'}", "✅" if registered else "❌")
        status_text = status_text.replace("{'Completed' if registered else 'Not completed'}", registered_status_text_en)
        
    status_text = status_text.replace("{wallet_count}", str(len(wallets)))
    
    # Добавляем список кошельков
    if wallets:
        status_text += "\nСписок кошельков:\n" if user_lang == 'ru' else "\nWallet list:\n" if user_lang == 'en' else "\nWallet list:\n"
        for wallet in wallets:
            wallet_line = get_text('wallet_list_item', user_lang).replace("{wallet_id}", str(wallet[0]))
            status_text += wallet_line
    
    await callback.message.answer(status_text)
    await callback.answer()

@dp.callback_query(F.data == "menu_help")
async def menu_help(callback: types.CallbackQuery):
    user_lang = get_user_language(callback.from_user)
    help_text = get_text('help_text', user_lang)
    await callback.message.answer(help_text)
    await callback.answer()

@dp.callback_query(F.data == "menu_back_to_main")
async def menu_back_to_main(callback: types.CallbackQuery):
    user_lang = get_user_language(callback.from_user)
    # Создаем клавиатуру главного меню
    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
        [types.InlineKeyboardButton(text=get_text('menu_register', user_lang), callback_data="menu_register")],
        [types.InlineKeyboardButton(text=get_text('menu_wallets', user_lang), callback_data="menu_wallets")],
        [types.InlineKeyboardButton(text=get_text('menu_sign', user_lang), callback_data="menu_sign")],
        [types.InlineKeyboardButton(text=get_text('menu_status', user_lang), callback_data="menu_status")],
        [types.InlineKeyboardButton(text=get_text('menu_help', user_lang), callback_data="menu_help")],
    ])
    welcome_text = get_text('start_message', user_lang)
    await callback.message.edit_text(welcome_text, reply_markup=keyboard)
    await callback.answer()

# Мастер добавления кошелька
@dp.callback_query(F.data == "wallet_add")
async def start_add_wallet_wizard(callback: types.CallbackQuery, state: FSMContext):
    user_id = callback.from_user.id
    user_lang = get_user_language(callback.from_user)
    if not is_registered(user_id):
        await callback.message.answer(get_text('not_registered', user_lang))
        await callback.answer()
        return

    prompt = get_text('enter_pubkey1', user_lang) or "Введите первый публичный ключ:"
    await callback.message.answer(prompt)
    await state.set_state(AddWalletStates.waiting_for_pubkey1)
    await callback.answer()

@dp.message(AddWalletStates.waiting_for_pubkey1)
async def process_pubkey1(message: types.Message, state: FSMContext):
    user_lang = get_user_language(message.from_user)
    await state.update_data(pubkey1=message.text.strip())
    prompt = get_text('enter_pubkey2', user_lang) or "Введите второй публичный ключ:"
    await message.answer(prompt)
    await state.set_state(AddWalletStates.waiting_for_pubkey2)

@dp.message(AddWalletStates.waiting_for_pubkey2)
async def process_pubkey2(message: types.Message, state: FSMContext):
    user_lang = get_user_language(message.from_user)
    await state.update_data(pubkey2=message.text.strip())
    prompt = get_text('enter_pubkey3', user_lang) or "Введите третий публичный ключ:"
    await message.answer(prompt)
    await state.set_state(AddWalletStates.waiting_for_pubkey3)

@dp.message(AddWalletStates.waiting_for_pubkey3)
async def process_pubkey3(message: types.Message, state: FSMContext):
    user_lang = get_user_language(message.from_user)
    await state.update_data(pubkey3=message.text.strip())
    prompt = get_text('enter_encrypted_key', user_lang) or "Введите зашифрованный приватный ключ (см. /encrypt_key):"
    await message.answer(prompt)
    await state.set_state(AddWalletStates.waiting_for_encrypted_key)

@dp.message(AddWalletStates.waiting_for_encrypted_key)
async def process_encrypted_key(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    data = await state.get_data()
    
    pubkey1 = data['pubkey1']
    pubkey2 = data['pubkey2']
    pubkey3 = data['pubkey3']
    encrypted_key = message.text.strip()

    try:
        if not all(len(pk) == 66 and pk.startswith(('02', '03')) for pk in [pubkey1, pubkey2, pubkey3]):
            error_msg = get_text('invalid_pubkey_format', user_lang) or "❌ Ошибка: Один или несколько публичных ключей имеют неверный формат."
            await message.answer(error_msg)
            await state.clear()
            return

        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("SELECT COALESCE(MAX(wallet_id), 0) + 1 FROM wallets WHERE user_id = ?", (user_id,))
        wallet_id = c.fetchone()[0]
        c.execute("INSERT INTO wallets (user_id, wallet_id, multisig_pubkeys, encrypted_key) "
                  "VALUES (?, ?, ?, ?)", (user_id, wallet_id, f"{pubkey1},{pubkey2},{pubkey3}", encrypted_key))
        conn.commit()
        conn.close()

        success_msg = (get_text('wallet_added_success', user_lang) or "✅ Кошелек #{wallet_id} успешно добавлен!\n\n"
                       "Теперь установите лимиты через меню 'Кошельки' → 'Лимиты и настройки'.")
        success_msg = success_msg.replace("{wallet_id}", str(wallet_id))
        await message.answer(success_msg)
        logging.info(f"User {user_id} added wallet #{wallet_id} via wizard")

    except Exception as e:
        error_msg = (get_text('error_adding_wallet', user_lang) or "❌ Ошибка при добавлении кошелька: {error}").replace("{error}", str(e))
        await message.answer(error_msg)
        logging.error(f"Error adding wallet for user {user_id} via wizard: {str(e)}")
    
    finally:
        await state.clear()

# Мастер установки лимитов
@dp.callback_query(F.data == "wallet_limits")
async def start_set_limits_wizard(callback: types.CallbackQuery, state: FSMContext):
    user_id = callback.from_user.id
    user_lang = get_user_language(callback.from_user)
    if not is_registered(user_id):
        await callback.message.answer(get_text('not_registered', user_lang))
        await callback.answer()
        return

    wallets = get_user_wallets(user_id)
    if not wallets:
        no_wallets_msg = get_text('no_wallets_yet', user_lang)
        await callback.message.answer(no_wallets_msg)
        await callback.answer()
        return

    # Создаем кнопки для выбора кошелька
    keyboard_buttons = []
    for wallet in wallets:
        wallet_id = wallet[0]
        wallet_text = f"Кошелёк #{wallet_id}" if user_lang == 'ru' else f"Wallet #{wallet_id}"
        keyboard_buttons.append([types.InlineKeyboardButton(text=wallet_text, callback_data=f"limits_wallet_{wallet_id}")])
    keyboard_buttons.append([types.InlineKeyboardButton(text=get_text('menu_wallets', user_lang), callback_data="menu_wallets")])
    
    keyboard = types.InlineKeyboardMarkup(inline_keyboard=keyboard_buttons)
    prompt = get_text('select_wallet_for_limits', user_lang) or "Выберите кошелёк для установки лимитов:"
    await callback.message.edit_text(prompt, reply_markup=keyboard)
    await callback.answer()

@dp.callback_query(F.data.startswith("limits_wallet_"))
async def limits_wallet_selected(callback: types.CallbackQuery, state: FSMContext):
    user_lang = get_user_language(callback.from_user)
    wallet_id = int(callback.data.split("_")[-1])
    await state.update_data(wallet_id=wallet_id)
    prompt = get_text('enter_monthly_limit', user_lang) or "Введите месячный лимит (BTC):"
    await callback.message.answer(prompt)
    await state.set_state(SetLimitsStates.waiting_for_monthly_limit)
    await callback.answer()

@dp.message(SetLimitsStates.waiting_for_monthly_limit)
async def process_monthly_limit(message: types.Message, state: FSMContext):
    user_lang = get_user_language(message.from_user)
    try:
        monthly_limit = float(message.text.strip())
        await state.update_data(monthly_limit=monthly_limit)
        prompt = get_text('enter_min_fee', user_lang) or "Введите минимальную комиссию (BTC):"
        await message.answer(prompt)
        await state.set_state(SetLimitsStates.waiting_for_min_fee)
    except ValueError:
        error_msg = get_text('please_enter_number', user_lang) or "Пожалуйста, введите числовое значение."
        await message.answer(error_msg)

@dp.message(SetLimitsStates.waiting_for_min_fee)
async def process_min_fee(message: types.Message, state: FSMContext):
    user_lang = get_user_language(message.from_user)
    try:
        min_fee = float(message.text.strip())
        await state.update_data(min_fee=min_fee)
        prompt = get_text('enter_max_fee', user_lang) or "Введите максимальную комиссию (BTC):"
        await message.answer(prompt)
        await state.set_state(SetLimitsStates.waiting_for_max_fee)
    except ValueError:
        error_msg = get_text('please_enter_number', user_lang) or "Пожалуйста, введите числовое значение."
        await message.answer(error_msg)

@dp.message(SetLimitsStates.waiting_for_max_fee)
async def process_max_fee(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    try:
        max_fee = float(message.text.strip())
        data = await state.get_data()
        wallet_id = data['wallet_id']
        monthly_limit = data['monthly_limit']
        min_fee = data['min_fee']

        if not wallet_exists(user_id, wallet_id):
            error_msg = (get_text('wallet_not_found', user_lang) or "Кошелек #{wallet_id} не найден.").replace("{wallet_id}", str(wallet_id))
            await message.answer(error_msg)
            await state.clear()
            return

        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("UPDATE wallets SET monthly_limit_btc = ?, min_fee_btc = ?, max_fee_btc = ? "
                  "WHERE user_id = ? AND wallet_id = ?",
                  (monthly_limit, min_fee, max_fee, user_id, wallet_id))
        conn.commit()
        conn.close()
        
        success_msg = (get_text('limits_set_success', user_lang) or "✅ Лимиты для кошелька #{wallet_id} установлены:\n"
                       "• Месячный лимит: {monthly_limit} BTC\n"
                       "• Комиссия: {min_fee}–{max_fee} BTC.")
        success_msg = success_msg.replace("{wallet_id}", str(wallet_id))
        success_msg = success_msg.replace("{monthly_limit}", str(monthly_limit))
        success_msg = success_msg.replace("{min_fee}", str(min_fee))
        success_msg = success_msg.replace("{max_fee}", str(max_fee))
        await message.answer(success_msg)
        logging.info(f"User {user_id} set limits for wallet #{wallet_id}: {monthly_limit}, {min_fee}, {max_fee}")
        
    except ValueError:
        error_msg = get_text('please_enter_number', user_lang) or "Пожалуйста, введите числовое значение."
        await message.answer(error_msg)
    except Exception as e:
        error_msg = (get_text('error_setting_limits', user_lang) or "❌ Ошибка: {error}").replace("{error}", str(e))
        await message.answer(error_msg)
        logging.error(f"Error setting limits for user {user_id}: {str(e)}")
    finally:
        await state.clear()

# Мастер управления белым списком
@dp.callback_query(F.data == "wallet_whitelist")
async def start_whitelist_wizard(callback: types.CallbackQuery):
    user_id = callback.from_user.id
    user_lang = get_user_language(callback.from_user)
    if not is_registered(user_id):
        await callback.message.answer(get_text('not_registered', user_lang))
        await callback.answer()
        return

    # Создаем подменю для белого списка
    keyboard = types.InlineKeyboardMarkup(inline_keyboard=[
        [types.InlineKeyboardButton(text=get_text('whitelist_add', user_lang), callback_data="whitelist_add")],
        [types.InlineKeyboardButton(text=get_text('whitelist_remove', user_lang), callback_data="whitelist_remove")],
        [types.InlineKeyboardButton(text=get_text('whitelist_view', user_lang), callback_data="whitelist_view")],
        [types.InlineKeyboardButton(text=get_text('menu_wallets', user_lang), callback_data="menu_wallets")],
    ])
    prompt = get_text('whitelist_management', user_lang) or "📋 Управление белым списком:"
    await callback.message.edit_text(prompt, reply_markup=keyboard)
    await callback.answer()

@dp.callback_query(F.data == "whitelist_add")
async def start_add_address_wizard(callback: types.CallbackQuery, state: FSMContext):
    user_id = callback.from_user.id
    user_lang = get_user_language(callback.from_user)
    wallets = get_user_wallets(user_id)
    if not wallets:
        no_wallets_msg = get_text('no_wallets_yet', user_lang)
        await callback.message.answer(no_wallets_msg)
        await callback.answer()
        return

    # Создаем кнопки для выбора кошелька
    keyboard_buttons = []
    for wallet in wallets:
        wallet_id = wallet[0]
        wallet_text = f"Кошелёк #{wallet_id}" if user_lang == 'ru' else f"Wallet #{wallet_id}"
        keyboard_buttons.append([types.InlineKeyboardButton(text=wallet_text, callback_data=f"add_addr_wallet_{wallet_id}")])
    keyboard_buttons.append([types.InlineKeyboardButton(text=get_text('wallet_whitelist', user_lang), callback_data="wallet_whitelist")])
    
    keyboard = types.InlineKeyboardMarkup(inline_keyboard=keyboard_buttons)
    prompt = get_text('select_wallet_for_address', user_lang) or "Выберите кошелёк для добавления адреса:"
    await callback.message.edit_text(prompt, reply_markup=keyboard)
    await callback.answer()

@dp.callback_query(F.data.startswith("add_addr_wallet_"))
async def add_addr_wallet_selected(callback: types.CallbackQuery, state: FSMContext):
    user_lang = get_user_language(callback.from_user)
    wallet_id = int(callback.data.split("_")[-1])
    await state.update_data(wallet_id=wallet_id)
    prompt = get_text('enter_address_to_add', user_lang) or "Введите адрес Bitcoin для добавления в белый список:"
    await callback.message.answer(prompt)
    await state.set_state(WhitelistStates.waiting_for_address_to_add)
    await callback.answer()

@dp.message(WhitelistStates.waiting_for_address_to_add)
async def process_address_to_add(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    address = message.text.strip()
    data = await state.get_data()
    wallet_id = data['wallet_id']

    if not wallet_exists(user_id, wallet_id):
        error_msg = (get_text('wallet_not_found', user_lang) or "Кошелек #{wallet_id} не найден.").replace("{wallet_id}", str(wallet_id))
        await message.answer(error_msg)
        await state.clear()
        return

    try:
        # Простая проверка формата адреса (можно улучшить)
        if not (address.startswith("bc1") or address.startswith("1") or address.startswith("3")):
            error_msg = get_text('invalid_address_format', user_lang) or "❌ Неверный формат адреса Bitcoin."
            await message.answer(error_msg)
            await state.clear()
            return
            
        add_address(user_id, wallet_id, address)
        success_msg = (get_text('address_added_success', user_lang) or "✅ Адрес {address} добавлен в белый список кошелька #{wallet_id}.")
        success_msg = success_msg.replace("{address}", address)
        success_msg = success_msg.replace("{wallet_id}", str(wallet_id))
        await message.answer(success_msg)
        logging.info(f"Address {address} added to whitelist for wallet #{wallet_id} by user {user_id}")
    except Exception as e:
        error_msg = (get_text('error_adding_address', user_lang) or "❌ Ошибка: {error}").replace("{error}", str(e))
        await message.answer(error_msg)
        logging.error(f"Error adding address for user {user_id}: {str(e)}")
    finally:
        await state.clear()

@dp.callback_query(F.data == "whitelist_remove")
async def start_remove_address_wizard(callback: types.CallbackQuery, state: FSMContext):
    user_id = callback.from_user.id
    user_lang = get_user_language(callback.from_user)
    wallets = get_user_wallets(user_id)
    if not wallets:
        no_wallets_msg = get_text('no_wallets_yet', user_lang)
        await callback.message.answer(no_wallets_msg)
        await callback.answer()
        return

    # Создаем кнопки для выбора кошелька
    keyboard_buttons = []
    for wallet in wallets:
        wallet_id = wallet[0]
        wallet_text = f"Кошелёк #{wallet_id}" if user_lang == 'ru' else f"Wallet #{wallet_id}"
        keyboard_buttons.append([types.InlineKeyboardButton(text=wallet_text, callback_data=f"remove_addr_wallet_{wallet_id}")])
    keyboard_buttons.append([types.InlineKeyboardButton(text=get_text('wallet_whitelist', user_lang), callback_data="wallet_whitelist")])
    
    keyboard = types.InlineKeyboardMarkup(inline_keyboard=keyboard_buttons)
    prompt = get_text('select_wallet_for_address', user_lang) or "Выберите кошельк для удаления адреса:"
    await callback.message.edit_text(prompt, reply_markup=keyboard)
    await callback.answer()

@dp.callback_query(F.data.startswith("remove_addr_wallet_"))
async def remove_addr_wallet_selected(callback: types.CallbackQuery, state: FSMContext):
    user_lang = get_user_language(callback.from_user)
    wallet_id = int(callback.data.split("_")[-1])
    await state.update_data(wallet_id=wallet_id)
    prompt = get_text('enter_address_to_remove', user_lang) or "Введите адрес Bitcoin для удаления из белого списка:"
    await callback.message.answer(prompt)
    await state.set_state(WhitelistStates.waiting_for_address_to_remove)
    await callback.answer()

@dp.message(WhitelistStates.waiting_for_address_to_remove)
async def process_address_to_remove(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    address = message.text.strip()
    data = await state.get_data()
    wallet_id = data['wallet_id']

    if not wallet_exists(user_id, wallet_id):
        error_msg = (get_text('wallet_not_found', user_lang) or "Кошелек #{wallet_id} не найден.").replace("{wallet_id}", str(wallet_id))
        await message.answer(error_msg)
        await state.clear()
        return

    try:
        remove_address(user_id, wallet_id, address)
        success_msg = (get_text('address_removed_success', user_lang) or "✅ Адрес {address} удален из белого списка кошелька #{wallet_id}.")
        success_msg = success_msg.replace("{address}", address)
        success_msg = success_msg.replace("{wallet_id}", str(wallet_id))
        await message.answer(success_msg)
        logging.info(f"Address {address} removed from whitelist for wallet #{wallet_id} by user {user_id}")
    except Exception as e:
        error_msg = (get_text('error_removing_address', user_lang) or "❌ Ошибка: {error}").replace("{error}", str(e))
        await message.answer(error_msg)
        logging.error(f"Error removing address for user {user_id}: {str(e)}")
    finally:
        await state.clear()

@dp.callback_query(F.data == "whitelist_view")
async def view_whitelist(callback: types.CallbackQuery):
    user_id = callback.from_user.id
    user_lang = get_user_language(callback.from_user)
    wallets = get_user_wallets(user_id)
    if not wallets:
        no_wallets_msg = get_text('no_wallets_yet', user_lang)
        await callback.message.answer(no_wallets_msg)
        await callback.answer()
        return

    try:
        response = get_text('whitelist_header', user_lang) or "📋 Белые списки ваших кошельков:\n\n"
        for wallet in wallets:
            wallet_id = wallet[0]
            whitelist = get_whitelist(user_id, wallet_id)
            wallet_line = (get_text('whitelist_wallet_item', user_lang) or "Кошелёк #{wallet_id}:\n").replace("{wallet_id}", str(wallet_id))
            response += wallet_line
            if whitelist:
                for addr in list(whitelist)[:5]: # Ограничиваем для читаемости
                    response += f"  • {addr}\n"
                if len(whitelist) > 5:
                    response += f"  ... и ещё {len(whitelist) - 5}\n"
            else:
                empty_msg = get_text('whitelist_empty', user_lang) or "  (пусто)\n"
                response += empty_msg
            response += "\n"
        await callback.message.answer(response)
    except Exception as e:
        error_msg = (get_text('error_viewing_whitelist', user_lang) or "❌ Ошибка: {error}").replace("{error}", str(e))
        await callback.message.answer(error_msg)
        logging.error(f"Error viewing whitelist for user {user_id}: {str(e)}")
    await callback.answer()

# Команда /reset
@dp.message(Command("reset"))
async def reset_state(message: types.Message, state: FSMContext):
    user_lang = get_user_language(message.from_user)
    await state.clear()
    success_msg = get_text('state_reset', user_lang) or "🔄 Состояние сброшено. Можете начать заново."
    await message.answer(success_msg)
    logging.info(f"State reset for user {message.from_user.id}")

# === ОСНОВНАЯ ЛОГИКА БОТА (с небольшими изменениями для локализации) ===

# Обработчик команды /register
@dp.message(Command("register"))
async def register_command(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    logging.info(f"Received /register command from user {user_id} (lang: {user_lang}), chat type: {message.chat.type}")
    try:
        if is_registered(user_id):
            already_registered_msg = get_text('already_registered', user_lang)
            await message.answer(already_registered_msg)
            return
        if message.is_topic_message or message.chat.type != "private":
            private_chat_msg = get_text('private_chat_required', user_lang)
            await message.answer(private_chat_msg)
            return
        totp_secret = pyotp.random_base32()
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("INSERT INTO users (user_id, totp_secret) VALUES (?, ?)", (user_id, totp_secret))
        conn.commit()
        conn.close()
        totp = pyotp.TOTP(totp_secret)
        qr_url = totp.provisioning_uri(name=f"BitcoinSigner_{user_id}", issuer_name="YourBot")
        
        success_msg = (get_text('registration_success', user_lang) or 
                      "✅ Регистрация завершена!\n\n"
                      "Настройте Google Authenticator:\n{qr_url}\n\n"
                      "Теперь добавьте кошелек через меню /start → 'Кошельки' → 'Добавить кошелёк'")
        success_msg = success_msg.replace("{qr_url}", qr_url)
        await message.answer(success_msg)
        logging.info(f"User {user_id} registered")
    except Exception as e:
        error_msg = (get_text('error_during_registration', user_lang) or "❌ Ошибка при регистрации: {error}").replace("{error}", str(e))
        await message.answer(error_msg)
        logging.error(f"Error in /register for user {user_id}: {str(e)}")

# Обработчик команды /encrypt_key
@dp.message(Command("encrypt_key"))
async def encrypt_key_command(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    logging.info(f"Received /encrypt_key command from user {user_id} (lang: {user_lang}), chat type: {message.chat.type}")
    try:
        if not is_registered(user_id):
            not_registered_msg = get_text('not_registered', user_lang)
            await message.answer(not_registered_msg)
            return
        if message.is_topic_message or message.chat.type != "private":
            private_chat_msg = get_text('private_chat_required', user_lang)
            await message.answer(private_chat_msg)
            return
        parts = message.text.split(maxsplit=1)[1].split(maxsplit=1)
        private_key, password = parts
        encrypted_key = encrypt_key(private_key, password)
        
        success_msg = (get_text('key_encrypted_success', user_lang) or 
                      "✅ Зашифрованный ключ:\n<code>{encrypted_key}</code>\n\n"
                      "Используйте его при добавлении кошелька через меню.")
        success_msg = success_msg.replace("{encrypted_key}", encrypted_key)
        await message.answer(success_msg, parse_mode="HTML")
        logging.info(f"User {user_id} encrypted a key")
    except IndexError:
        usage_msg = get_text('encrypt_key_usage', user_lang) or "Укажите ключ и пароль: /encrypt_key <private_key> <password>"
        await message.answer(usage_msg)
        logging.error(f"Invalid /encrypt_key command by user {user_id}")
    except Exception as e:
        error_msg = (get_text('error_encrypting_key', user_lang) or "❌ Ошибка: {error}").replace("{error}", str(e))
        await message.answer(error_msg)
        logging.error(f"Error in /encrypt_key for user {user_id}: {str(e)}")

# Обработчик команды /view_settings
@dp.message(Command("view_settings"))
async def view_settings_command(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    logging.info(f"Received /view_settings command from user {user_id} (lang: {user_lang}), chat type: {message.chat.type}")
    try:
        if not is_registered(user_id):
            not_registered_msg = get_text('not_registered', user_lang)
            await message.answer(not_registered_msg)
            return
        if message.is_topic_message or message.chat.type != "private":
            private_chat_msg = get_text('private_chat_required', user_lang)
            await message.answer(private_chat_msg)
            return
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("SELECT wallet_id, monthly_limit_btc, min_fee_btc, max_fee_btc, multisig_pubkeys "
                  "FROM wallets WHERE user_id = ?", (user_id,))
        wallets = c.fetchall()
        
        if not wallets:
            no_wallets_msg = get_text('no_wallets_configured', user_lang) or "Кошельки не настроены. Добавьте через меню /start → 'Кошельки' → 'Добавить кошелёк'"
            await message.answer(no_wallets_msg)
            conn.close()
            return
            
        settings_header = get_text('settings_header', user_lang) or "📊 Ваши кошельки:"
        settings_lines = [settings_header]
        for wallet in wallets:
            wallet_id, monthly_limit, min_fee, max_fee, pubkeys = wallet
            whitelist = get_whitelist(user_id, wallet_id)
            
            wallet_info = (get_text('wallet_settings_item', user_lang) or 
                          "\nКошелек #{wallet_id}:\n"
                          "  Месячный лимит: {monthly_limit} BTC\n"
                          "  Комиссия: {min_fee}–{max_fee} BTC\n"
                          "  Публичные ключи: {pubkeys}\n"
                          "  Белый список: {whitelist}")
            
            # Форматируем белый список
            formatted_whitelist = ', '.join(list(whitelist)[:3])
            if len(whitelist) > 3:
                formatted_whitelist += '...'
            if not whitelist:
                formatted_whitelist = get_text('whitelist_empty_short', user_lang) or 'пусто'
                
            wallet_info = wallet_info.replace("{wallet_id}", str(wallet_id))
            wallet_info = wallet_info.replace("{monthly_limit}", str(monthly_limit))
            wallet_info = wallet_info.replace("{min_fee}", str(min_fee))
            wallet_info = wallet_info.replace("{max_fee}", str(max_fee))
            wallet_info = wallet_info.replace("{pubkeys}", pubkeys or (get_text('not_set', user_lang) or 'не установлены'))
            wallet_info = wallet_info.replace("{whitelist}", formatted_whitelist)
            
            settings_lines.append(wallet_info)
        conn.close()
        await message.answer("\n".join(settings_lines))
        logging.info(f"User {user_id} viewed settings")
    except Exception as e:
        error_msg = (get_text('error_viewing_settings', user_lang) or "❌ Ошибка: {error}").replace("{error}", str(e))
        await message.answer(error_msg)
        logging.error(f"Error in /view_settings for user {user_id}: {str(e)}")

# Обработчик статических QR-кодов
@dp.message(F.photo)
async def handle_qr_code(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    logging.info(f"Received QR code from user {user_id} (lang: {user_lang})")
    if not is_registered(user_id):
        not_registered_msg = get_text('not_registered', user_lang)
        await message.answer(not_registered_msg)
        return
    if message.is_topic_message or message.chat.type != "private":
        private_chat_msg = get_text('private_chat_required', user_lang)
        await message.answer(private_chat_msg)
        return
    if check_blocked(user_id):
        blocked_msg = get_text('too_many_attempts', user_lang) or "Слишком много неверных попыток. Попробуйте позже."
        await message.answer(blocked_msg)
        return
    photo = message.photo[-1]
    file = await bot.get_file(photo.file_id)
    file_bytes = await bot.download_file(file.file_path)
    psbt_data, error = extract_psbt_from_qr(file_bytes)
    if error:
        await message.answer(error)
        logging.error(f"QR code processing error for user {user_id}: {error}")
        return
    try:
        try:
            tx = transaction.Transaction.parse(base64.b64decode(psbt_data))
            hex_tx = psbt_data
        except:
            try:
                tx = transaction.Transaction.parse(bytes.fromhex(psbt_data))
                hex_tx = psbt_data
            except Exception as e:
                error_msg = (get_text('error_processing_psbt', user_lang) or "❌ Ошибка обработки PSBT: {error}").replace("{error}", str(e))
                await message.answer(error_msg)
                logging.error(f"Invalid PSBT format for user {user_id}: {str(e)}")
                return
        await message.answer("✅ PSBT получен. Выберите кошелёк для подписи через меню /start → 'Подписать'.")
        await state.update_data(hex_tx=hex_tx)
        # Не устанавливаем состояние await_2fa сразу, ждем выбора кошелька
        logging.info(f"PSBT received from QR code for user {user_id}")
    except Exception as e:
        error_msg = (get_text('error_processing_psbt', user_lang) or "❌ Ошибка обработки PSBT: {error}").replace("{error}", str(e))
        await message.answer(error_msg)
        logging.error(f"Error processing PSBT for user {user_id}: {str(e)}")

# Обработчик видео с анимированными QR-кодами
@dp.message(F.video)
async def handle_qr_video(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    logging.info(f"Received video from user {user_id} (lang: {user_lang})")
    if not is_registered(user_id):
        not_registered_msg = get_text('not_registered', user_lang)
        await message.answer(not_registered_msg)
        return
    if message.is_topic_message or message.chat.type != "private":
        private_chat_msg = get_text('private_chat_required', user_lang)
        await message.answer(private_chat_msg)
        return
    if check_blocked(user_id):
        blocked_msg = get_text('too_many_attempts', user_lang) or "Слишком много неверных попыток. Попробуйте позже."
        await message.answer(blocked_msg)
        return
    file = await bot.get_file(message.video.file_id)
    file_bytes = await bot.download_file(file.file_path)
    def preprocess_frame(frame):
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
        return clahe.apply(gray)
    qreader = QReader()
    cap = cv2.VideoCapture(io.BytesIO(file_bytes))
    decoder = URDecoder()
    frame_count = 0
    qr_count = 0
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        frame_count += 1
        if frame_count % 2 == 0:  # Анализируем каждый второй кадр
            decoded = qreader.detect_and_decode(image=preprocess_frame(frame))
            if decoded and decoded[0]:
                qr_count += 1
                logging.info(f"Frame {frame_count}: QR code found - {decoded[0]}")
                decoder.receive(decoded[0])
                if decoder.is_complete():
                    break # Досрочно выходим, если собрали всё
    cap.release()
    logging.info(f"Processed {frame_count} frames, found {qr_count} QR codes")
    if not qr_count:
        no_qr_msg = get_text('no_qr_in_video', user_lang) or "❌ QR-коды не найдены в видео. Убедитесь, что QR-код чёткий и занимает большую часть кадра."
        await message.answer(no_qr_msg)
        logging.error(f"No QR codes found in video for user {user_id}")
        return
    if decoder.is_complete():
        psbt_data = decoder.result().decode()
        logging.info(f"PSBT assembled successfully for user {user_id}")
    else:
        incomplete_msg = get_text('incomplete_psbt', user_lang) or "❌ Не удалось собрать полный PSBT. Попробуйте записать видео ещё раз, держа камеру неподвижно."
        await message.answer(incomplete_msg)
        logging.error(f"Incomplete PSBT assembly for user {user_id}")
        return
    try:
        tx = transaction.Transaction.parse(base64.b64decode(psbt_data))
        hex_tx = psbt_data
    except:
        try:
            tx = transaction.Transaction.parse(bytes.fromhex(psbt_data))
            hex_tx = psbt_data
        except Exception as e:
            error_msg = (get_text('error_processing_psbt', user_lang) or "❌ Ошибка обработки PSBT: {error}").replace("{error}", str(e))
            await message.answer(error_msg)
            logging.error(f"Invalid PSBT format for user {user_id}: {str(e)}")
            return
    await message.answer("✅ PSBT получен. Выберите кошелёк для подписи через меню /start → 'Подписать'.")
    await state.update_data(hex_tx=hex_tx)
    # Не устанавливаем состояние await_2fa сразу, ждем выбора кошелька
    logging.info(f"PSBT received from video for user {user_id}")

# Обработчик команды /sign_transaction
@dp.message(Command("sign_transaction"))
async def sign_transaction(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    logging.info(f"Received /sign_transaction command from user {user_id} (lang: {user_lang}), chat type: {message.chat.type}")
    try:
        if not is_registered(user_id):
            not_registered_msg = get_text('not_registered', user_lang)
            await message.answer(not_registered_msg)
            logging.warning(f"Unregistered user {user_id} attempted to sign transaction")
            return
        if message.is_topic_message or message.chat.type != "private":
            private_chat_msg = get_text('private_chat_required', user_lang)
            await message.answer(private_chat_msg)
            return
        if check_blocked(user_id):
            blocked_msg = get_text('too_many_attempts', user_lang) or "Слишком много неверных попыток. Попробуйте позже."
            await message.answer(blocked_msg)
            logging.warning(f"User {user_id} blocked due to too many failed attempts")
            return
        parts = message.text.split(maxsplit=1)
        if len(parts) < 2:
            usage_msg = get_text('sign_transaction_usage', user_lang) or "Укажите ID кошелька и PSBT: /sign_transaction <wallet_id> <hex_tx>"
            await message.answer(usage_msg)
            logging.error(f"Invalid /sign_transaction command by user {user_id}: missing arguments")
            return
        args = parts[1].split(maxsplit=1)
        if len(args) < 2:
            usage_msg = get_text('sign_transaction_usage', user_lang) or "Укажите ID кошелька и PSBT: /sign_transaction <wallet_id> <hex_tx>"
            await message.answer(usage_msg)
            logging.error(f"Invalid /sign_transaction command by user {user_id}: missing PSBT")
            return
        wallet_id = int(args[0])
        hex_tx = args[1]
        try:
            tx = transaction.Transaction.parse(bytes.fromhex(hex_tx))
        except ValueError:
            try:
                tx = transaction.Transaction.parse(base64.b64decode(hex_tx))
            except Exception as e:
                error_msg = (get_text('invalid_psbt_format', user_lang) or "❌ Ошибка: Неверный формат PSBT: {error}").replace("{error}", str(e))
                await message.answer(error_msg)
                logging.error(f"Invalid PSBT format for user {user_id}: {str(e)}")
                return
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("SELECT monthly_limit_btc, min_fee_btc, max_fee_btc, multisig_pubkeys, encrypted_key "
                  "FROM wallets WHERE user_id = ? AND wallet_id = ?",
                  (user_id, wallet_id))
        wallet = c.fetchone()
        conn.close()
        if not wallet:
            error_msg = (get_text('wallet_not_found', user_lang) or "Кошелек #{wallet_id} не найден.").replace("{wallet_id}", str(wallet_id))
            await message.answer(error_msg)
            logging.error(f"Wallet #{wallet_id} not found for user {user_id}")
            return
        monthly_limit, min_fee, max_fee, pubkeys, encrypted_key = wallet
        pubkeys = pubkeys.split(",") if pubkeys else []
        if not pubkeys or not encrypted_key:
            config_msg = get_text('configure_wallet_first', user_lang) or "Настройте кошелек: /add_wallet"
            await message.answer(config_msg)
            logging.error(f"Wallet #{wallet_id} not configured for user {user_id}")
            return
        amount_btc = sum(output.value for output in tx.vout) / 1e8
        if not check_monthly_limit(user_id, wallet_id, amount_btc):
            error_msg = (get_text('amount_exceeds_limit', user_lang) or 
                        "❌ Ошибка: сумма {amount_btc} BTC превышает месячный лимит {monthly_limit} BTC.")
            error_msg = error_msg.replace("{amount_btc}", str(amount_btc))
            error_msg = error_msg.replace("{monthly_limit}", str(monthly_limit))
            await message.answer(error_msg)
            logging.error(f"Transaction rejected for user {user_id}, wallet #{wallet_id}: amount {amount_btc} exceeds monthly limit")
            return
        fee_btc = (sum(inp.witness[-1].value for inp in tx.vin if inp.witness) - sum(out.value for out in tx.vout)) / 1e8
        if fee_btc < min_fee or fee_btc > max_fee:
            error_msg = (get_text('fee_out_of_range', user_lang) or 
                        "❌ Ошибка: комиссия {fee_btc} BTC вне диапазона [{min_fee}, {max_fee}] BTC.")
            error_msg = error_msg.replace("{fee_btc}", str(fee_btc))
            error_msg = error_msg.replace("{min_fee}", str(min_fee))
            error_msg = error_msg.replace("{max_fee}", str(max_fee))
            await message.answer(error_msg)
            logging.error(f"Transaction rejected for user {user_id}, wallet #{wallet_id}: fee {fee_btc} out of range")
            return
        whitelist = get_whitelist(user_id, wallet_id)
        payment_addresses = set()
        change_address = None
        for output in tx.vout:
            addr = output.script_pubkey.address(NETWORK)
            if addr in whitelist:
                payment_addresses.add(addr)
            else:
                change_address = addr
        if not payment_addresses:
            error_msg = get_text('no_addresses_in_whitelist', user_lang) or "❌ Ошибка: ни один адрес получателя не найден в белом списке."
            await message.answer(error_msg)
            logging.error(f"Transaction rejected for user {user_id}, wallet #{wallet_id}: no payment addresses in whitelist")
            return
        if change_address and not check_change_address(change_address, pubkeys):
            error_msg = (get_text('change_address_invalid', user_lang) or 
                        "❌ Ошибка: адрес сдачи {change_address} не принадлежит кошельку.")
            error_msg = error_msg.replace("{change_address}", change_address)
            await message.answer(error_msg)
            logging.error(f"Transaction rejected for user {user_id}, wallet #{wallet_id}: change address {change_address} not valid")
            return
        details = (f"📝 Получена транзакция для кошелька #{wallet_id}:\n"
                   f"• Сумма: {amount_btc} BTC\n"
                   f"• Адрес(а) получателя: {', '.join(list(payment_addresses)[:3]) + ('...' if len(payment_addresses) > 3 else '')}\n"
                   f"• Адрес сдачи: {change_address or 'нет'} (принадлежит кошельку)\n"
                   f"• Комиссия: {fee_btc} BTC\n\n"
                   f"Введите код Google Authenticator.")
        await message.answer(details)
        await state.set_state(TransactionStates.await_2fa)
        await state.update_data(
            hex_tx=hex_tx,
            wallet_id=wallet_id,
            amount_btc=amount_btc,
            attempts=0
        )
        logging.info(f"Transaction received from user {user_id}, wallet #{wallet_id}: amount {amount_btc}, fee {fee_btc}")
    except Exception as e:
        error_msg = (get_text('error_processing_transaction', user_lang) or "❌ Ошибка: {error}").replace("{error}", str(e))
        await message.answer(error_msg)
        logging.error(f"Error processing transaction for user {user_id}: {str(e)}")

# Обработчик ввода 2FA-кода
@dp.message(TransactionStates.await_2fa)
async def process_2fa(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    logging.info(f"Received 2FA input from user {user_id} (lang: {user_lang}), chat type: {message.chat.type}")
    try:
        if not is_registered(user_id):
            not_registered_msg = get_text('not_registered', user_lang)
            await message.answer(not_registered_msg)
            await state.clear()
            return
        if message.is_topic_message or message.chat.type != "private":
            private_chat_msg = get_text('private_chat_required', user_lang)
            await message.answer(private_chat_msg)
            await state.clear()
            return
        if check_blocked(user_id):
            blocked_msg = get_text('too_many_attempts', user_lang) or "Слишком много неверных попыток. Попробуйте позже."
            await message.answer(blocked_msg)
            await state.clear()
            return
        data = await state.get_data()
        attempts = data.get("attempts", 0) + 1
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("SELECT totp_secret FROM users WHERE user_id = ?", (user_id,))
        totp_secret = c.fetchone()[0]
        conn.close()
        totp = pyotp.TOTP(totp_secret)
        if not totp.verify(message.text):
            if attempts >= MAX_2FA_ATTEMPTS:
                update_attempts(user_id, attempts)
                block_msg = (get_text('blocked_too_many_attempts', user_lang) or 
                            "❌ Слишком много неверных попыток. Блокировка на {minutes} минут.")
                block_msg = block_msg.replace("{minutes}", str(BLOCK_DURATION // 60))
                await message.answer(block_msg)
                logging.warning(f"User {user_id} blocked after {attempts} failed 2FA attempts")
                await state.clear()
            else:
                await state.update_data(attempts=attempts)
                attempts_left = MAX_2FA_ATTEMPTS - attempts
                error_msg = (get_text('invalid_2fa_code', user_lang) or 
                            "❌ Неверный код 2FA. Осталось {attempts_left} попыток.")
                error_msg = error_msg.replace("{attempts_left}", str(attempts_left))
                await message.answer(error_msg)
                logging.warning(f"Invalid 2FA code by user {user_id}, attempt {attempts}")
            return
        prompt_msg = get_text('enter_password_to_decrypt', user_lang) or "Введите пароль для расшифровки ключа."
        await message.answer(prompt_msg)
        await state.set_state(TransactionStates.await_password)
        logging.info(f"User {user_id} passed 2FA verification")
    except Exception as e:
        error_msg = (get_text('error_during_2fa', user_lang) or "❌ Ошибка: {error}").replace("{error}", str(e))
        await message.answer(error_msg)
        logging.error(f"Error in 2FA processing for user {user_id}: {str(e)}")
        await state.clear()

# Обработчик ввода пароля
@dp.message(TransactionStates.await_password)
async def process_password(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    logging.info(f"Received password input from user {user_id} (lang: {user_lang}), chat type: {message.chat.type}")
    try:
        if not is_registered(user_id):
            not_registered_msg = get_text('not_registered', user_lang)
            await message.answer(not_registered_msg)
            await state.clear()
            return
        if message.is_topic_message or message.chat.type != "private":
            private_chat_msg = get_text('private_chat_required', user_lang)
            await message.answer(private_chat_msg)
            await state.clear()
            return
        data = await state.get_data()
        wallet_id = data["wallet_id"]
        hex_tx = data["hex_tx"]
        amount_btc = data["amount_btc"]
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("SELECT encrypted_key, multisig_pubkeys FROM wallets WHERE user_id = ? AND wallet_id = ?",
                  (user_id, wallet_id))
        wallet = c.fetchone()
        if not wallet:
            error_msg = (get_text('wallet_not_found', user_lang) or "Кошелек #{wallet_id} не найден.").replace("{wallet_id}", str(wallet_id))
            await message.answer(error_msg)
            await state.clear()
            return
        encrypted_key, pubkeys = wallet
        pubkeys = pubkeys.split(",") if pubkeys else []
        conn.close()
        private_key = decrypt_key(encrypted_key, message.text)
        key = ec.PrivateKey.parse(bytes.fromhex(private_key))
        try:
            tx = transaction.Transaction.parse(bytes.fromhex(hex_tx))
        except ValueError:
            tx = transaction.Transaction.parse(base64.b64decode(hex_tx))
        pubkeys = [ec.PublicKey.parse(bytes.fromhex(pk)) for pk in pubkeys]
        multisig = script.ScriptMultisig(m=2, pubkeys=sorted(pubkeys, key=lambda x: x.serialize()))
        p2wsh = script.p2wsh(multisig)
        for i, inp in enumerate(tx.vin):
            tx.sign_input(i, private_key=key, script_pubkey=p2wsh)
        conn = sqlite3.connect(DB_PATH)
        c = conn.cursor()
        c.execute("INSERT INTO transactions (user_id, wallet_id, timestamp, amount_btc) VALUES (?, ?, ?, ?)",
                  (user_id, wallet_id, datetime.now().isoformat(), amount_btc))
        conn.commit()
        conn.close()
        signed_psbt = tx.serialize().hex()
        qr_data = create_qr_code(signed_psbt)
        caption_msg = (get_text('signed_psbt_caption', user_lang) or "✅ Подписанный PSBT для кошелька #{wallet_id}").replace("{wallet_id}", str(wallet_id))
        await message.answer_photo(qr_data, caption=caption_msg)
        await message.answer(f"Подписанный PSBT (текст):\n<code>{signed_psbt}</code>", parse_mode="HTML")
        logging.info(f"Transaction signed for user {user_id}, wallet #{wallet_id}")
        await state.clear()
    except Exception as e:
        error_msg = (get_text('error_signing_transaction', user_lang) or "❌ Ошибка: {error}").replace("{error}", str(e))
        await message.answer(error_msg)
        logging.error(f"Error signing transaction for user {user_id}: {str(e)}")
        await state.clear()

# Улучшенный обработчик некомандных сообщений с автоопределением
@dp.message(~Command(commands=["start", "register", "encrypt_key", "add_wallet", "set_limits", "view_settings", "add_address", "remove_address", "sign_transaction", "status", "reset"]))
async def handle_any_input(message: types.Message, state: FSMContext):
    user_id = message.from_user.id
    user_lang = get_user_language(message.from_user)
    current_state = await state.get_state()
    logging.info(f"Received any input from user {user_id} (lang: {user_lang}), text/photo/video: present, state: {current_state}")

    # Если пользователь находится в процессе FSM - обрабатываем как обычно
    if current_state is not None:
        # Передаём сообщение в текущий обработчик состояния
        await dp.propagate_event(update_type="message", event=message)
        return

    # Если это фото (QR-код)
    if message.photo:
        await handle_qr_code(message, state)
        return

    # Если это видео (анимированный QR)
    if message.video:
        await handle_qr_video(message, state)
        return

    # Если это текст
    if message.text:
        text = message.text.strip()

        # Похоже на WIF-ключ
        if text.startswith(("Kw", "L", "cP", "cR")) and len(text) > 40:
            prompt_msg = get_text('looks_like_private_key', user_lang) or "🔑 Похоже, вы отправили приватный ключ. Используйте команду /encrypt_key для его шифрования."
            await message.answer(prompt_msg)
            return

        # Похоже на часть UR
        if text.lower().startswith("ur:"):
            prompt_msg = get_text('looks_like_ur_part', user_lang) or "🌀 Это часть UR-кода. Отправьте полное видео с анимацией или статический QR-код."
            await message.answer(prompt_msg)
            return

        # Похоже на HEX или Base64 PSBT
        if len(text) > 50:
            # Проверим, можно ли это распарсить как PSBT
            try:
                # Пробуем HEX
                tx = transaction.Transaction.parse(bytes.fromhex(text))
                prompt_msg = get_text('psbt_received_hex', user_lang) or "📝 Получен PSBT в формате HEX. Обрабатываю..."
                await message.answer(prompt_msg)
                sign_prompt = get_text('use_sign_transaction_hex', user_lang) or "Для подписания используйте команду:\n/sign_transaction <wallet_id> <ваш_hex_psbt>"
                await message.answer(sign_prompt)
                return
            except:
                try:
                    # Пробуем Base64
                    tx = transaction.Transaction.parse(base64.b64decode(text))
                    prompt_msg = get_text('psbt_received_base64', user_lang) or "📝 Получен PSBT в формате Base64. Обрабатываю..."
                    await message.answer(prompt_msg)
                    sign_prompt = get_text('use_sign_transaction_base64', user_lang) or "Для подписания используйте команду:\n/sign_transaction <wallet_id> <ваш_base64_psbt>"
                    await message.answer(sign_prompt)
                    return
                except:
                    pass # Не PSBT

        # Если ничего не подошло
        if is_registered(user_id):
            unknown_format_msg = (get_text('unknown_data_format_registered', user_lang) or 
                                 "🤔 Не удалось распознать формат данных.\n\n"
                                 "Поддерживаются:\n"
                                 "• Статический QR-код (фото)\n"
                                 "• Анимированный QR (видео)\n"
                                 "• Текст PSBT (HEX или Base64)\n\n"
                                 "Или используйте кнопки меню: /start")
            await message.answer(unknown_format_msg)
        else:
            greeting_msg = get_text('greeting_unregistered', user_lang) or "👋 Привет! Я BitcoinSignerBot. Начните с регистрации через меню /start"
            await message.answer(greeting_msg)
        return

# Запуск бота
async def main():
    init_db()
    await dp.start_polling(bot)

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