uploader-bot/app/bot/routers/tonconnect.py

import asyncio
import json
from datetime import datetime, timedelta

from aiogram import types, Router, F
from aiogram.filters import Command

from app.bot.routers.home import send_connect_wallets_list, send_home_menu
from app.core._blockchain.ton.connect import TonConnect, unpack_wallet_info
from sqlalchemy import select, and_
from app.core._keyboards import get_inline_keyboard
from app.core._utils.tg_process_template import tg_process_template
from app.core.logger import make_log
from app.core.models.wallet_connection import WalletConnection

router = Router()


async def pause_ton_connection(ton_connect: TonConnect):
    if ton_connect.connected:
        ton_connect._sdk_client.pause_connection()


async def t_tonconnect_dev_menu(message: types.Message, memory=None, user=None, db_session=None, chat_wrap=None, **extra):
    try:
        command_args = message.text.split(" ")[1:]
    except BaseException as e:
        command_args = []

    make_log("TonConnect_DevMenu", f"Command args: {command_args}", level='info')
    wallet_app_name = 'tonkeeper'
    if len(command_args) > 0:
        wallet_app_name = command_args[0].lower()

    keyboard = []

    # Restore recent connection
    result = await db_session.execute(select(WalletConnection).where(
        and_(WalletConnection.user_id == user.id, WalletConnection.invalidated == False, WalletConnection.network == 'ton')
    ).order_by(WalletConnection.created.desc()))
    ton_connection = result.scalars().first()
    ton_connect = TonConnect.by_key(ton_connection.keys["connection_key"]) if ton_connection else TonConnect()
    make_log("TonConnect_DevMenu", f"Available wallets: {ton_connect._sdk_client.get_wallets()}", level='debug')
    if ton_connection:
        await ton_connect.restore_connection()
    make_log("TonConnect_DevMenu", f"SDK connected?: {ton_connect.connected}", level='info')
    if not ton_connect.connected:
        if ton_connection:
            make_log("TonConnect_DevMenu", f"Invalidating old connection", level='debug')
            ton_connection.invalidated = True
            await db_session.commit()

        message_text = f"""<b>Wallet is not connected</b>
        
Use /dev_tonconnect <code>{wallet_app_name}</code> for connect to wallet."""
        connection_link = await ton_connect.new_connection(wallet_app_name)
        ton_connect.connected
        make_log("TonConnect_DevMenu", f"New connection link for {wallet_app_name}: {connection_link}", level='debug')
        keyboard.append([
            {
                'text': 'Connect',
                'url': connection_link
            }
        ])
    else:
        wallet_info_text = json.dumps(unpack_wallet_info(ton_connect._sdk_client._wallet), indent=4, ensure_ascii=False)
        message_text = f"""<b>Wallet is connected</b>
        
<pre>{wallet_info_text}</pre>"""

    memory.add_task(pause_ton_connection, ton_connect, delay_s=60 * 3)

    return await tg_process_template(
        chat_wrap, message_text,
        keyboard=get_inline_keyboard(keyboard) if keyboard else None
    )


async def t_callback_init_tonconnect(query: types.CallbackQuery, memory=None, user=None, db_session=None, chat_wrap=None, **extra):
    wallet_app_name = query.data.split("_")[1]
    result = await db_session.execute(select(WalletConnection).where(
        and_(WalletConnection.user_id == user.id, WalletConnection.invalidated == False, WalletConnection.network == 'ton')
    ).order_by(WalletConnection.created.desc()))
    ton_connection = result.scalars().first()
    ton_connect = TonConnect.by_key(ton_connection.keys["connection_key"]) if ton_connection else TonConnect()
    if ton_connection:
        await ton_connect.restore_connection()
    connection_link = await ton_connect.new_connection(wallet_app_name)
    ton_connect.connected
    memory.add_task(pause_ton_connection, ton_connect, delay_s=60 * 3)
    make_log("TonConnect_Init", f"New connection link for {wallet_app_name}: {connection_link}", level='debug')
    message_text = user.translated("tonconnectInit_menu")
    r = await tg_process_template(
        chat_wrap, message_text,
        keyboard=get_inline_keyboard([
            [
                {
                    'text': user.translated('tonconnectOpenWallet_button'),
                    'url': connection_link
                }
            ],
            [
                {
                    'text': user.translated('home_button'),
                    'callback_data': 'home'
                }
            ]
        ]), message_id=query.message.message_id
    )

    start_ts = datetime.now()
    while datetime.now() - start_ts < timedelta(seconds=180):
        new_connection = (await db_session.execute(select(WalletConnection).where(
            and_(WalletConnection.user_id == user.id, WalletConnection.invalidated == False)
        ))).scalars().first()
        if new_connection:
            await tg_process_template(
                chat_wrap, user.translated('p_successConnectWallet')
            )
            await send_home_menu(chat_wrap, user, new_connection)
            break

        await asyncio.sleep(1)

    return r


async def t_callback_disconnect_wallet(query: types.CallbackQuery, memory=None, user=None, db_session=None, chat_wrap=None, **extra):
    wallet_connections = (await db_session.execute(select(WalletConnection).where(
        and_(WalletConnection.user_id == user.id, WalletConnection.invalidated == False)
    ))).scalars().all()
    for wallet_connection in wallet_connections:
        wallet_connection.invalidated = True

    await db_session.commit()

    return await send_home_menu(chat_wrap, user, None, message_id=query.message.message_id)


async def t_command_debug_webapp(message, memory=None, user=None, db_session=None, chat_wrap=None, **extra):
    webapp_url = message.text.split(' ')[1]
    await tg_process_template(
        chat_wrap, f"<b>WebApp Debug</b>",
        keyboard=get_inline_keyboard([
            [
                {
                    'text': 'Open',
                    'web_app': types.WebAppInfo(url=webapp_url)
                }
            ]
        ])
    )

router.message.register(t_tonconnect_dev_menu, Command('dev_tonconnect'))
router.callback_query.register(t_callback_init_tonconnect, F.data.startswith('initTonconnect_'))
router.callback_query.register(t_callback_disconnect_wallet, F.data == 'disconnectWallet')
router.message.register(t_command_debug_webapp, Command('debug_webapp'))