import { renderHeader } from '../components/header.js';
import { authService, state } from '../state.js';
import {
  createRandomSolanaWallet,
  createSolanaWalletFromPrivateBase58,
  formatSol,
  getBalanceSol,
  getTopupSiteUrl,
  getWalletFromStoredClientKey,
  transferSol,
} from '../services/solana-wallet-service.js';
import {
  formatAr,
  getArweaveBalance,
  getArweaveTopupSiteUrl,
  getArweaveWalletFromStoredClientKey,
  transferAr,
} from '../services/arweave-wallet-service.js';
import { loadEncryptedUserSecrets } from '../services/key-vault.js';
import { loadSolanaWeb3 } from '../vendor/solana-web3-loader.js';
import {
  calcLimitTopupPriceLamports,
  getLimitStepBytes,
  getShineBlockchainUsage,
  getShineUsersEconomyConfig,
  updateShineUserPdaOnSolana,
} from '../services/shine-blockchain-wallet-service.js?v=202605300007';

export const pageMeta = { id: 'wallet-view', title: 'Кошелёк' };
const SOLANA_PRIVATE_BASE58_MAX_LEN = 44;

function nowRu() {
  return new Date().toLocaleString('ru-RU');
}

function formatKbFromBytes(rawBytes) {
  const bytes = typeof rawBytes === 'bigint'
    ? Number(rawBytes)
    : Number(rawBytes || 0);
  if (!Number.isFinite(bytes) || bytes <= 0) return '0 KB';
  const kb = bytes / 1024;
  return `${kb.toLocaleString('ru-RU', { minimumFractionDigits: 2, maximumFractionDigits: 2 })} KB`;
}

function lamportsToSolText(lamportsBigInt) {
  const value = Number(lamportsBigInt || 0n) / 1_000_000_000;
  return value.toLocaleString('ru-RU', { minimumFractionDigits: 0, maximumFractionDigits: 9 });
}

function createModeBackButton(renderWalletChoice) {
  const backBtn = document.createElement('button');
  backBtn.className = 'text-btn';
  backBtn.textContent = '← К выбору кошелька';
  backBtn.addEventListener('click', () => {
    renderWalletChoice();
  });
  return backBtn;
}

function sessionArgsOrThrow() {
  const login = String(state.session.login || '').trim();
  const storagePwd = String(state.session.storagePwdInMemory || '').trim();
  if (!login || !storagePwd) {
    throw new Error('Нет активной сессии. Выполните вход заново.');
  }
  return { login, storagePwd };
}

const SHINE_PAYMENTS_PROGRAM_ID = 'c4yTa4JT9EtQDCBX9LmWFK6T2gp4JGsuymFbom2EudW';
const SHINE_PAYMENTS_ORACLE_ACCOUNT = '7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE';
const SHINE_PAYMENTS_SEEDS = {
  config: 'shine_payments_config',
  coef: 'shine_payments_coef_limit',
  queues: 'shine_payments_queues',
  inflow: 'shine_payments_inflow_vault',
  q1: 'shine_payments_q1_ticket',
  q2: 'shine_payments_q2_ticket',
  q3: 'shine_payments_q3_ticket',
};
const COEF_SCALE_PPM = 1_000_000n;
const LAMPORTS_PER_SOL = 1_000_000_000n;
const SUPPORT_TICKET_HELP_TEXT = [
  'Билет привязан к очереди 1 и к адресу получателя, который вы укажете при покупке.',
  'Оплата считается в USD, а списание идет в SOL по курсу USDT/SOL, который проверяется в момент транзакции.',
  'Если курс уезжает слишком далеко, покупка отклоняется. Для интерфейса заложен допуск 3%.',
  'Когда текущий лимит очереди заполнится, откроется новый лимит с более низким коэффициентом.',
  'Номер билета нужно сохранить отдельно: именно по нему удобно отслеживать, когда он дойдет до выплаты.',
].join('\n');

function utf8Bytes(text) {
  return new TextEncoder().encode(String(text || ''));
}

function concatBytes(...parts) {
  const total = parts.reduce((sum, part) => sum + part.length, 0);
  const out = new Uint8Array(total);
  let offset = 0;
  parts.forEach((part) => {
    out.set(part, offset);
    offset += part.length;
  });
  return out;
}

function u64ToBytes(value) {
  const out = new Uint8Array(8);
  let current = BigInt(value || 0);
  for (let i = 0; i < 8; i += 1) {
    out[i] = Number(current & 0xffn);
    current >>= 8n;
  }
  return out;
}

function readU64(data, offset) {
  let value = 0n;
  for (let i = 0; i < 8; i += 1) {
    value |= BigInt(data[offset + i]) << (8n * BigInt(i));
  }
  return value;
}

function readI64(data, offset) {
  let value = readU64(data, offset);
  if (value > 0x7fffffffffffffffn) {
    value -= 0x10000000000000000n;
  }
  return value;
}

function readI32(data, offset) {
  let value = Number(readU64(data, offset) & 0xffffffffn);
  if (value > 0x7fffffff) value -= 0x100000000;
  return value;
}

function trimZeros(value) {
  return String(value || '')
    .replace(/(\.\d*?[1-9])0+$/u, '$1')
    .replace(/\.0+$/u, '')
    .replace(/\.$/u, '');
}

function formatUsdCentsText(cents) {
  const value = Number(cents || 0n) / 100;
  return value.toLocaleString('ru-RU', { minimumFractionDigits: 0, maximumFractionDigits: 2 });
}

function formatPpmCoefText(coefPpm) {
  const value = Number(coefPpm || 0n) / Number(COEF_SCALE_PPM);
  return `${trimZeros(value.toFixed(6))}x`;
}

function formatLamportsSolText(lamports, digits = 9) {
  const value = Number(lamports || 0n) / Number(LAMPORTS_PER_SOL);
  return value.toLocaleString('ru-RU', { minimumFractionDigits: 0, maximumFractionDigits: digits });
}

function formatPythSolUsdText(pyth) {
  const value = Number(pyth?.priceNum || 0n) / Number(pyth?.priceDen || 1n) / 100;
  return trimZeros(value.toFixed(6));
}

function formatQueuePrefix(queueId) {
  if (queueId === 2) return 'Q2';
  if (queueId === 3) return 'Q3';
  return 'Q1';
}

function parsePaymentsCoef(data) {
  let offset = 0;
  const version = data[offset];
  offset += 1;
  const coefPpm = readU64(data, offset); offset += 8;
  const limitUsdCents = readU64(data, offset); offset += 8;
  const callRewardLamports = readU64(data, offset);
  return { version, coefPpm, limitUsdCents, callRewardLamports };
}

function parsePaymentsQueues(data) {
  let offset = 0;
  const version = data[offset];
  offset += 1;
  const q1TicketsTotal = readU64(data, offset); offset += 8;
  const q1TicketsPaid = readU64(data, offset); offset += 8;
  const q1SumTotalUsdCents = readU64(data, offset); offset += 8;
  const q1SumPaidUsdCents = readU64(data, offset); offset += 8;
  const q2TicketsTotal = readU64(data, offset); offset += 8;
  const q2TicketsPaid = readU64(data, offset); offset += 8;
  const q2SumTotalUsdCents = readU64(data, offset); offset += 8;
  const q2SumPaidUsdCents = readU64(data, offset); offset += 8;
  const q3TicketsTotal = readU64(data, offset); offset += 8;
  const q3TicketsPaid = readU64(data, offset); offset += 8;
  const q3SumTotalUsdCents = readU64(data, offset); offset += 8;
  const q3SumPaidUsdCents = readU64(data, offset);
  return {
    version,
    q1TicketsTotal,
    q1TicketsPaid,
    q1SumTotalUsdCents,
    q1SumPaidUsdCents,
    q2TicketsTotal,
    q2TicketsPaid,
    q2SumTotalUsdCents,
    q2SumPaidUsdCents,
    q3TicketsTotal,
    q3TicketsPaid,
    q3SumTotalUsdCents,
    q3SumPaidUsdCents,
  };
}

function parsePaymentsTicket(data) {
  let offset = 0;
  const version = data[offset];
  offset += 1;
  const queueId = data[offset];
  offset += 1;
  const index = readU64(data, offset);
  offset += 8;
  const isPaid = Boolean(data[offset]);
  offset += 1;
  const solana = window.solanaWeb3;
  const recipientWallet = new solana.PublicKey(data.slice(offset, offset + 32)).toBase58();
  offset += 32;
  const payoutUsdCents = readU64(data, offset);
  offset += 8;
  const debtBeforeUsdCents = readU64(data, offset);
  return {
    version,
    queueId,
    index,
    isPaid,
    recipientWallet,
    payoutUsdCents,
    debtBeforeUsdCents,
  };
}

function parseSupportTicketInput(rawValue) {
  const clean = String(rawValue || '').trim();
  if (!clean) throw new Error('Введите номер билета.');
  if (/^\d+$/.test(clean)) {
    return { queueId: 1, index: BigInt(clean) };
  }
  const match = clean.match(/^([123])(?:\s*[-_:\/#]+\s*|\s+)(\d+)$/);
  if (!match) {
    throw new Error('Формат: для Q1 просто номер, для Q2/Q3 - например 2-15 или 3 8.');
  }
  return {
    queueId: Number(match[1]),
    index: BigInt(match[2]),
  };
}

async function deriveSupportRandomWallet(extraText) {
  const solana = await loadSolanaWeb3();
  if (!window.crypto?.getRandomValues || !window.crypto?.subtle) {
    throw new Error('Этот браузер не поддерживает безопасную генерацию ключей.');
  }
  const entropy = new Uint8Array(32);
  window.crypto.getRandomValues(entropy);
  const payload = concatBytes(
    entropy,
    utf8Bytes(extraText || ''),
    utf8Bytes(new Date().toISOString()),
    utf8Bytes(String(Date.now())),
    utf8Bytes(String(performance?.now?.() || 0)),
  );
  const seed = new Uint8Array(await window.crypto.subtle.digest('SHA-256', payload));
  const keypair = solana.Keypair.fromSeed(seed);
  return {
    address: keypair.publicKey.toBase58(),
    privateKey32Base58: solana.bs58.encode(seed),
    keypair,
    generatedAt: new Date().toLocaleString('ru-RU'),
  };
}

async function loadSupportPaymentsCore(endpoint) {
  const solana = await loadSolanaWeb3();
  const rpc = String(endpoint || '').trim();
  const connection = new solana.Connection(rpc, 'confirmed');
  const programId = new solana.PublicKey(SHINE_PAYMENTS_PROGRAM_ID);
  const oracleAccount = new solana.PublicKey(SHINE_PAYMENTS_ORACLE_ACCOUNT);
  const [configPda] = solana.PublicKey.findProgramAddressSync([utf8Bytes(SHINE_PAYMENTS_SEEDS.config)], programId);
  const [coefPda] = solana.PublicKey.findProgramAddressSync([utf8Bytes(SHINE_PAYMENTS_SEEDS.coef)], programId);
  const [queuesPda] = solana.PublicKey.findProgramAddressSync([utf8Bytes(SHINE_PAYMENTS_SEEDS.queues)], programId);
  const [inflowPda] = solana.PublicKey.findProgramAddressSync([utf8Bytes(SHINE_PAYMENTS_SEEDS.inflow)], programId);
  const [oracleAi, configAi, coefAi, queuesAi] = await Promise.all([
    connection.getAccountInfo(oracleAccount, 'confirmed'),
    connection.getAccountInfo(configPda, 'confirmed'),
    connection.getAccountInfo(coefPda, 'confirmed'),
    connection.getAccountInfo(queuesPda, 'confirmed'),
  ]);
  if (!oracleAi) throw new Error('Не найден аккаунт оракула SOL/USD.');
  if (!configAi || !coefAi || !queuesAi) throw new Error('PDA программы оплаты ещё не инициализированы.');

  const parsePrice = (data) => {
    const price = readI64(data, 73);
    const exponent = readI32(data, 89);
    const publishTime = readI64(data, 93);
    if (price <= 0n) throw new Error('Оракул вернул некорректную цену.');
    let num = price * 100n;
    let den = 1n;
    if (exponent >= 0) {
      num *= 10n ** BigInt(exponent);
    } else {
      den *= 10n ** BigInt(-exponent);
    }
    return { priceNum: num, priceDen: den, publishTime };
  };

  let configOffset = 0;
  const configVersion = configAi.data[configOffset];
  configOffset += 1;
  const daoWallet = new solana.PublicKey(configAi.data.slice(configOffset, configOffset + 32)).toBase58();
  configOffset += 32;
  const inflowVault = new solana.PublicKey(configAi.data.slice(configOffset, configOffset + 32)).toBase58();

  return {
    connection,
    programId,
    oracleAccount,
    configPda,
    coefPda,
    queuesPda,
    inflowPda,
    config: { version: configVersion, daoWallet, inflowVault },
    coef: parsePaymentsCoef(coefAi.data),
    queues: parsePaymentsQueues(queuesAi.data),
    pyth: parsePrice(oracleAi.data),
  };
}

function queueStateView(queues, queueId) {
  if (queueId === 2) {
    return {
      ticketsTotal: queues.q2TicketsTotal,
      ticketsPaid: queues.q2TicketsPaid,
      sumTotalUsdCents: queues.q2SumTotalUsdCents,
      sumPaidUsdCents: queues.q2SumPaidUsdCents,
    };
  }
  if (queueId === 3) {
    return {
      ticketsTotal: queues.q3TicketsTotal,
      ticketsPaid: queues.q3TicketsPaid,
      sumTotalUsdCents: queues.q3SumTotalUsdCents,
      sumPaidUsdCents: queues.q3SumPaidUsdCents,
    };
  }
  return {
    ticketsTotal: queues.q1TicketsTotal,
    ticketsPaid: queues.q1TicketsPaid,
    sumTotalUsdCents: queues.q1SumTotalUsdCents,
    sumPaidUsdCents: queues.q1SumPaidUsdCents,
  };
}

function queueSeedFor(queueId) {
  if (queueId === 2) return SHINE_PAYMENTS_SEEDS.q2;
  if (queueId === 3) return SHINE_PAYMENTS_SEEDS.q3;
  return SHINE_PAYMENTS_SEEDS.q1;
}

function ticketPdaFor(programId, queueId, index) {
  const solana = window.solanaWeb3;
  return solana.PublicKey.findProgramAddressSync(
    [utf8Bytes(queueSeedFor(queueId)), u64ToBytes(index)],
    programId,
  );
}

export function render({ navigate }) {
  const screen = document.createElement('section');
  screen.className = 'stack';

  const status = document.createElement('p');
  status.className = 'meta-muted';
  const setStatus = (text) => {
    status.textContent = String(text || '');
  };

  const content = document.createElement('div');
  content.className = 'stack';

  screen.append(
    renderHeader({
      title: 'Кошелёк',
      leftAction: { label: '←', onClick: () => navigate('profile-view') },
    }),
    content,
    status,
  );

  let activeModeToken = 0;
  let arweaveWalletCtx = null;

  function clearArweaveSecretsInMemory() {
    if (!arweaveWalletCtx?.jwk) return;
    Object.keys(arweaveWalletCtx.jwk).forEach((key) => {
      arweaveWalletCtx.jwk[key] = '';
    });
    arweaveWalletCtx.jwk = null;
    arweaveWalletCtx = null;
  }

  function renderSupportHub() {
    activeModeToken += 1;
    clearArweaveSecretsInMemory();
    content.innerHTML = '';

    const backBtn = createModeBackButton(renderWalletChoice);

    const intro = document.createElement('div');
    intro.className = 'card stack';
    intro.innerHTML = `
      <h2 style="margin:0;">Поддержать проект Сияние</h2>
      <p class="meta-muted" style="margin:0; line-height:1.5;">
        Здесь можно купить билет, посмотреть очередь и увидеть, как устроена покупка.
        Оплата идет в SOL, а сумма считается по курсу USD/USDT на момент транзакции.
        Номер билета и секретный ключ кошелька нужно сохранить отдельно.
      </p>
    `;

    const actions = document.createElement('div');
    actions.className = 'stack';
    actions.innerHTML = `
      <button class="primary-btn" type="button" id="support-buy" style="width:100%;">Купить билет</button>
      <button class="primary-btn" type="button" id="support-queue" style="width:100%;">Посмотреть очередь</button>
      <button class="primary-btn" type="button" id="support-keygen" style="width:100%;">Сгенерировать новую пару ключей</button>
    `;

    actions.querySelector('#support-buy')?.addEventListener('click', () => {
      void renderSupportBuy();
    });
    actions.querySelector('#support-queue')?.addEventListener('click', () => {
      void renderSupportQueue();
    });
    actions.querySelector('#support-keygen')?.addEventListener('click', () => {
      void renderSupportKeygen();
    });

    content.append(backBtn, intro, actions);
    setStatus('Выберите действие в разделе поддержки.');
  }

  async function renderSupportHelp(backTarget = renderSupportBuy) {
    const modeToken = ++activeModeToken;
    clearArweaveSecretsInMemory();
    content.innerHTML = '';

    const backBtn = createModeBackButton(backTarget);
    const card = document.createElement('div');
    card.className = 'card stack';
    card.innerHTML = `
      <h2 style="margin:0;">Справка по покупке билета</h2>
      <p class="meta-muted" style="margin:0; white-space:pre-wrap; line-height:1.55;">${SUPPORT_TICKET_HELP_TEXT}</p>
      <p class="meta-muted" style="margin:0;">
        После покупки билет остается в очереди 1. Позже можно открыть экран просмотра и проверить, сколько билетов и сумм уже прошло перед ним.
      </p>
    `;

    content.append(backBtn, card);
    if (modeToken === activeModeToken) setStatus('Открыта подробная справка.');
  }

  async function renderSupportKeygen() {
    const modeToken = ++activeModeToken;
    clearArweaveSecretsInMemory();
    content.innerHTML = '';

    const backBtn = createModeBackButton(renderSupportHub);
    const card = document.createElement('div');
    card.className = 'card stack';
    card.innerHTML = `
      <h2 style="margin:0;">Сгенерировать новую пару ключей</h2>
      <p class="meta-muted" style="margin:0; line-height:1.55;">
        Генерация использует безопасный рандом браузера, а ваш дополнительный текст и текущее время добавляются как примесь.
        Вводить текст необязательно: даже без него ключи остаются случайными.
      </p>
    `;

    const saltLabel = document.createElement('label');
    saltLabel.className = 'meta-muted';
    saltLabel.setAttribute('for', 'support-key-salt');
    saltLabel.textContent = 'Дополнительная соль (необязательно)';

    const saltInput = document.createElement('textarea');
    saltInput.id = 'support-key-salt';
    saltInput.rows = 3;
    saltInput.placeholder = 'Можно оставить пустым или добавить любой текст как дополнительную примесь';
    saltInput.spellcheck = false;

    const timeLabel = document.createElement('p');
    timeLabel.className = 'meta-muted';
    timeLabel.textContent = 'Время генерации появится после нажатия кнопки.';

    const generatedPublicLabel = document.createElement('label');
    generatedPublicLabel.className = 'meta-muted';
    generatedPublicLabel.setAttribute('for', 'support-generated-public');
    generatedPublicLabel.textContent = 'Публичный ключ';

    const generatedPublicInput = document.createElement('input');
    generatedPublicInput.id = 'support-generated-public';
    generatedPublicInput.type = 'text';
    generatedPublicInput.readOnly = true;
    generatedPublicInput.placeholder = 'Появится после генерации';

    const generatedSecretLabel = document.createElement('label');
    generatedSecretLabel.className = 'meta-muted';
    generatedSecretLabel.setAttribute('for', 'support-generated-secret');
    generatedSecretLabel.textContent = 'Секретный ключ (Base58, показывается один раз)';

    const generatedSecretInput = document.createElement('textarea');
    generatedSecretInput.id = 'support-generated-secret';
    generatedSecretInput.rows = 4;
    generatedSecretInput.readOnly = true;
    generatedSecretInput.placeholder = 'Появится после генерации';
    generatedSecretInput.spellcheck = false;

    const generatedAddressNote = document.createElement('p');
    generatedAddressNote.className = 'meta-muted';
    generatedAddressNote.style.margin = '0';
    generatedAddressNote.textContent = 'Secret key не сохраняется на сервере и не пишется в localStorage.';

    const actions = document.createElement('div');
    actions.className = 'stack';
    actions.innerHTML = `
      <button class="primary-btn" type="button" id="support-generate" style="width:100%;">Сгенерировать пару ключей</button>
      <div class="row">
        <button class="text-btn" type="button" id="support-copy-public" style="width:100%;">Копировать public key</button>
        <button class="text-btn" type="button" id="support-copy-secret" style="width:100%;">Копировать secret key</button>
      </div>
      <button class="ghost-btn" type="button" id="support-download" style="width:100%;">Скачать ключи</button>
    `;

    const generateBtn = actions.querySelector('#support-generate');
    const copyPublicBtn = actions.querySelector('#support-copy-public');
    const copySecretBtn = actions.querySelector('#support-copy-secret');
    const downloadBtn = actions.querySelector('#support-download');
    let generatedPair = null;

    const clearGenerated = () => {
      generatedPair = null;
      generatedPublicInput.value = '';
      generatedSecretInput.value = '';
      timeLabel.textContent = 'Время генерации появится после нажатия кнопки.';
    };

    clearGenerated();

    generateBtn?.addEventListener('click', async () => {
      generateBtn.disabled = true;
      try {
        generatedPair = await deriveSupportRandomWallet(saltInput.value);
        if (modeToken !== activeModeToken) return;
        generatedPublicInput.value = generatedPair.address;
        generatedSecretInput.value = generatedPair.privateKey32Base58;
        timeLabel.textContent = `Сгенерировано: ${generatedPair.generatedAt}. Использован безопасный рандом браузера, текст и время добавлены как примесь.`;
        setStatus('Новая пара ключей сгенерирована. Секретный ключ показан на экране один раз.');
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        setStatus(`Не удалось сгенерировать пару ключей: ${error?.message || 'unknown'}`);
      } finally {
        generateBtn.disabled = false;
      }
    });

    copyPublicBtn?.addEventListener('click', async () => {
      const value = String(generatedPublicInput.value || '').trim();
      if (!value) {
        setStatus('Сначала сгенерируйте пару ключей.');
        return;
      }
      try {
        await navigator.clipboard.writeText(value);
        setStatus('Public key скопирован.');
      } catch {
        setStatus('Не удалось скопировать public key.');
      }
    });

    copySecretBtn?.addEventListener('click', async () => {
      const value = String(generatedSecretInput.value || '').trim();
      if (!value) {
        setStatus('Сначала сгенерируйте пару ключей.');
        return;
      }
      try {
        await navigator.clipboard.writeText(value);
        setStatus('Secret key скопирован.');
      } catch {
        setStatus('Не удалось скопировать secret key.');
      }
    });

    downloadBtn?.addEventListener('click', () => {
      const publicKey = String(generatedPublicInput.value || '').trim();
      const secretKey = String(generatedSecretInput.value || '').trim();
      if (!publicKey || !secretKey) {
        setStatus('Сначала сгенерируйте пару ключей.');
        return;
      }
      const payload = [
        `Публичный ключ: ${publicKey}`,
        `Секретный ключ: ${secretKey}`,
        `Время: ${timeLabel.textContent || ''}`,
      ].join('\n');
      const blob = new Blob([payload], { type: 'text/plain;charset=utf-8' });
      const url = URL.createObjectURL(blob);
      const link = document.createElement('a');
      link.href = url;
      link.download = `shine-keypair-${Date.now()}.txt`;
      link.click();
      window.setTimeout(() => URL.revokeObjectURL(url), 0);
      setStatus('Файл с ключами скачан.');
    });

    content.append(
      backBtn,
      card,
      saltLabel,
      saltInput,
      timeLabel,
      generatedPublicLabel,
      generatedPublicInput,
      generatedSecretLabel,
      generatedSecretInput,
      generatedAddressNote,
      actions,
    );
    setStatus('Генератор ключей готов. Дополнительная соль необязательна.');
  }

  async function renderSupportQueue() {
    const modeToken = ++activeModeToken;
    clearArweaveSecretsInMemory();
    content.innerHTML = '';

    const backBtn = createModeBackButton(renderSupportHub);
    const card = document.createElement('div');
    card.className = 'card stack';
    card.innerHTML = `
      <h2 style="margin:0;">Посмотреть очередь билета</h2>
      <p class="meta-muted" style="margin:0; line-height:1.55;">
        Для Q1 вводите просто номер билета. Для Q2 и Q3 укажите номер в формате <code>2-15</code> или <code>3 8</code>.
        Экран покажет, сколько билетов перед ним уже стоит, сколько уже выплачено и кому принадлежит билет.
      </p>
    `;

    const inputLabel = document.createElement('label');
    inputLabel.className = 'meta-muted';
    inputLabel.setAttribute('for', 'support-ticket-query');
    inputLabel.textContent = 'Номер билета';

    const queryInput = document.createElement('input');
    queryInput.id = 'support-ticket-query';
    queryInput.type = 'text';
    queryInput.placeholder = 'Например: 12, 2-5 или 3 8';
    queryInput.autocomplete = 'off';
    queryInput.spellcheck = false;

    const actions = document.createElement('div');
    actions.className = 'row';
    actions.innerHTML = `
      <button class="primary-btn" type="button" id="support-ticket-load" style="width:100%;">Показать билет</button>
      <button class="ghost-btn" type="button" id="support-ticket-reset" style="width:100%;">Сбросить</button>
    `;

    const result = document.createElement('div');
    result.className = 'card stack';
    result.innerHTML = `
      <p class="meta-muted" style="margin:0;">Введите номер билета и нажмите кнопку.</p>
    `;

    let lastCoreState = null;

    const renderTicketInfo = async () => {
      const raw = String(queryInput.value || '').trim();
      if (!raw) {
        result.innerHTML = `<p class="meta-muted" style="margin:0;">Введите номер билета.</p>`;
        return;
      }
      try {
        const parsed = parseSupportTicketInput(raw);
        const core = lastCoreState || await loadSupportPaymentsCore(state.entrySettings.solanaServer);
        lastCoreState = core;
        const solana = await loadSolanaWeb3();
        const ticketPdaSeed = queueSeedFor(parsed.queueId);
        const ticketIndexBytes = u64ToBytes(parsed.index);
        const [ticketPda] = solana.PublicKey.findProgramAddressSync(
          [utf8Bytes(ticketPdaSeed), ticketIndexBytes],
          core.programId,
        );
        const ticketInfo = await core.connection.getAccountInfo(ticketPda, 'confirmed');
        if (!ticketInfo) {
          result.innerHTML = `
            <p class="meta-muted" style="margin:0;">Билет ${formatQueuePrefix(parsed.queueId)}-${parsed.index.toString()} пока не создан.</p>
          `;
          return;
        }
        const ticket = parsePaymentsTicket(ticketInfo.data);
        const queueState = queueStateView(core.queues, parsed.queueId);
        const ticketsBefore = parsed.index > 0n ? parsed.index - 1n : 0n;
        const paidBefore = queueState.ticketsPaid < ticketsBefore ? queueState.ticketsPaid : ticketsBefore;
        const remainingBefore = ticketsBefore > paidBefore ? ticketsBefore - paidBefore : 0n;
        result.innerHTML = `
          <div><b>Билет:</b> ${formatQueuePrefix(parsed.queueId)}-${ticket.index.toString()}</div>
          <div><b>Статус:</b> ${ticket.isPaid ? 'выплачен' : 'ожидает выплаты'}</div>
          <div><b>Получатель:</b> <span style="word-break:break-all;">${ticket.recipientWallet}</span></div>
          <div><b>До него в очереди:</b> ${ticketsBefore.toString()} билетов</div>
          <div><b>Из них уже выплачено:</b> ${paidBefore.toString()} билетов</div>
          <div><b>Ещё осталось до него:</b> ${remainingBefore.toString()} билетов</div>
          <div><b>Уже выплачено по сумме в очереди:</b> ${formatUsdCentsText(queueState.sumPaidUsdCents)} USD</div>
          <div><b>Сумма этого билета:</b> ${formatUsdCentsText(ticket.payoutUsdCents)} USD</div>
          <div><b>Накоплено до этого билета:</b> ${formatUsdCentsText(ticket.debtBeforeUsdCents)} USD в очереди до него</div>
        `;
        setStatus(`Билет ${formatQueuePrefix(parsed.queueId)}-${ticket.index.toString()} найден.`);
      } catch (error) {
        result.innerHTML = `<p class="meta-muted" style="margin:0;">${String(error?.message || 'Не удалось загрузить билет')}</p>`;
        setStatus(`Не удалось посмотреть билет: ${error?.message || 'unknown'}`);
      }
    };

    actions.querySelector('#support-ticket-load')?.addEventListener('click', () => {
      void renderTicketInfo();
    });
    actions.querySelector('#support-ticket-reset')?.addEventListener('click', () => {
      queryInput.value = '';
      result.innerHTML = `<p class="meta-muted" style="margin:0;">Введите номер билета и нажмите кнопку.</p>`;
      setStatus('Поле билета очищено.');
    });

    content.append(backBtn, card, inputLabel, queryInput, actions, result);
    setStatus('Просмотр билета готов. Введите номер в нужном формате.');
  }

  async function renderSupportBuy() {
    const modeToken = ++activeModeToken;
    clearArweaveSecretsInMemory();
    content.innerHTML = '';

    const backBtn = createModeBackButton(renderSupportHub);
    const helpCard = document.createElement('div');
    helpCard.className = 'card stack';
    helpCard.innerHTML = `
      <h2 style="margin:0;">Купить билет</h2>
      <p class="meta-muted" style="margin:0; line-height:1.55;">
        Вы покупаете только билет очереди 1. Сумма задается в USD, а оплата уходит в SOL по курсу USDT/SOL на момент транзакции.
        Покупка подписывается вашим client key. Интерфейс проверяет допуск по курсу до 3 процентов и не дает выходить за текущий лимит по коэффициенту.
      </p>
    `;

    const stateCard = document.createElement('div');
    stateCard.className = 'card stack';
    stateCard.innerHTML = `
      <p class="meta-muted" style="margin:0;">Текущее состояние покупки загружается...</p>
    `;

    const amountLabel = document.createElement('label');
    amountLabel.className = 'meta-muted';
    amountLabel.setAttribute('for', 'support-buy-amount');
    amountLabel.textContent = 'Сумма билета в долларах';

    const amountInput = document.createElement('input');
    amountInput.id = 'support-buy-amount';
    amountInput.type = 'text';
    amountInput.value = '20';
    amountInput.inputMode = 'decimal';
    amountInput.autocomplete = 'off';

    const recipientWrap = document.createElement('div');
    recipientWrap.className = 'stack';
    const recipientInput = document.createElement('input');
    recipientInput.id = 'support-buy-recipient';
    recipientInput.type = 'text';
    recipientInput.placeholder = 'Можно оставить пустым';
    recipientInput.autocomplete = 'off';
    recipientInput.spellcheck = false;
    const recipientLabel = document.createElement('label');
    recipientLabel.className = 'meta-muted';
    recipientLabel.setAttribute('for', 'support-buy-recipient');
    recipientLabel.textContent = 'Адрес кошелька для билета и выплаты';
    recipientWrap.append(recipientLabel, recipientInput);

    const sameWalletRow = document.createElement('label');
    sameWalletRow.className = 'row';
    sameWalletRow.style.gap = '10px';
    sameWalletRow.style.alignItems = 'center';
    sameWalletRow.innerHTML = `
      <input type="checkbox" id="support-buy-same-wallet" checked />
      <span class="meta-muted">На тот же кошелёк, с которого покупаем</span>
    `;

    const quoteCard = document.createElement('div');
    quoteCard.className = 'card stack';
    quoteCard.innerHTML = `<p class="meta-muted" style="margin:0;">Расчет появится после загрузки курса.</p>`;

    const purchaseResultCard = document.createElement('div');
    purchaseResultCard.className = 'card stack';
    purchaseResultCard.innerHTML = `
      <p class="meta-muted" style="margin:0;">После покупки здесь появится номер билета и краткий итог.</p>
    `;

    const actions = document.createElement('div');
    actions.className = 'stack';
    actions.innerHTML = `
      <div class="row">
        <button class="primary-btn" type="button" id="support-buy-submit" style="width:100%;">Купить</button>
        <button class="ghost-btn" type="button" id="support-buy-refresh" style="width:100%;">Обновить условия</button>
      </div>
      <button class="text-btn" type="button" id="support-buy-help" style="width:100%;">Справка</button>
    `;

    const buyBtn = actions.querySelector('#support-buy-submit');
    const refreshBtn = actions.querySelector('#support-buy-refresh');
    const helpBtn = actions.querySelector('#support-buy-help');
    const sameWalletCheckbox = sameWalletRow.querySelector('#support-buy-same-wallet');

    let walletCtx = null;
    let walletAddress = '';
    let currentCore = null;

    const setRecipientFromWallet = () => {
      if (sameWalletCheckbox?.checked && walletAddress) {
        recipientInput.value = walletAddress;
        recipientInput.disabled = true;
      } else {
        recipientInput.disabled = false;
      }
    };

    const updateQuote = () => {
      if (!currentCore) return;
      const queue = queueStateView(currentCore.queues, 1);
      const remainingUsdCents = currentCore.coef.limitUsdCents > queue.sumTotalUsdCents
        ? currentCore.coef.limitUsdCents - queue.sumTotalUsdCents
        : 0n;
      const currentCoef = formatPpmCoefText(currentCore.coef.coefPpm);
      const usdRaw = String(amountInput.value || '').trim().replace(',', '.');
      let amountUsdCents = 0n;
      let amountSol = '—';
      let maxPaySol = '—';
      let canBuy = true;
      try {
        const asNumber = Number(usdRaw);
        if (!Number.isFinite(asNumber) || asNumber <= 0) throw new Error('bad amount');
        amountUsdCents = BigInt(Math.round(asNumber * 100));
        const payLamports = (amountUsdCents * LAMPORTS_PER_SOL * currentCore.pyth.priceDen + currentCore.pyth.priceNum - 1n) / currentCore.pyth.priceNum;
        const maxPayLamports = (payLamports * 103n + 99n) / 100n;
        amountSol = formatLamportsSolText(payLamports, 9);
        maxPaySol = formatLamportsSolText(maxPayLamports, 9);
        if (amountUsdCents > remainingUsdCents) canBuy = false;
      } catch {
        canBuy = false;
      }

      quoteCard.innerHTML = `
        <div><b>Коэффициент сейчас:</b> ${currentCoef}</div>
        <div><b>В очереди перед вами уже куплено:</b> ${formatUsdCentsText(queue.sumTotalUsdCents)} USD</div>
        <div><b>Осталось до лимита текущего коэффициента:</b> ${formatUsdCentsText(remainingUsdCents)} USD</div>
        <div><b>Следующий билет:</b> №${(queue.ticketsTotal + 1n).toString()}</div>
        <div><b>Примерная цена:</b> ${amountSol} SOL</div>
        <div><b>Максимум при допуске 3%:</b> ${maxPaySol} SOL</div>
        <div class="${canBuy ? 'ok' : 'warn'}">${canBuy ? 'Покупка укладывается в текущий лимит.' : 'Сумма сейчас не укладывается в текущий лимит или введена некорректно.'}</div>
        <div class="meta-muted" style="margin:0; white-space:pre-wrap; line-height:1.5;">
          Если текущий лимит заполнится, откроется новый лимит с более низким коэффициентом.
          Покупка идет в SOL, но считается по курсу USD/USDT на момент транзакции.
        </div>
      `;
      const hasRecipient = sameWalletCheckbox?.checked
        ? Boolean(walletAddress)
        : Boolean(String(recipientInput.value || '').trim());
      buyBtn.disabled = !canBuy || !hasRecipient;
    };

    const refreshCore = async () => {
      refreshBtn.disabled = true;
      try {
        currentCore = await loadSupportPaymentsCore(state.entrySettings.solanaServer);
        if (modeToken !== activeModeToken) return;
        const queue = queueStateView(currentCore.queues, 1);
        const remainingUsdCents = currentCore.coef.limitUsdCents > queue.sumTotalUsdCents
          ? currentCore.coef.limitUsdCents - queue.sumTotalUsdCents
          : 0n;
        stateCard.innerHTML = `
          <div><b>Коэффициент:</b> ${formatPpmCoefText(currentCore.coef.coefPpm)}</div>
          <div><b>Лимит текущего коэффициента:</b> ${formatUsdCentsText(currentCore.coef.limitUsdCents)} USD</div>
          <div><b>Уже куплено в очереди 1:</b> ${formatUsdCentsText(queue.sumTotalUsdCents)} USD</div>
          <div><b>Осталось купить по текущему коэффициенту:</b> ${formatUsdCentsText(remainingUsdCents)} USD</div>
          <div><b>Сколько билетов уже в очереди:</b> ${queue.ticketsTotal.toString()}</div>
          <div><b>Следующий билет:</b> №${(queue.ticketsTotal + 1n).toString()}</div>
          <div><b>Курс:</b> 1 SOL = ${formatPythSolUsdText(currentCore.pyth)} USD</div>
          <div class="meta-muted" style="margin:0; line-height:1.5;">
            После заполнения лимита будет новый лимит, но уже с более низким коэффициентом.
          </div>
        `;
        setRecipientFromWallet();
        updateQuote();
        setStatus('Условия покупки обновлены.');
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        stateCard.innerHTML = `<p class="meta-muted" style="margin:0;">${String(error?.message || 'Не удалось загрузить состояние')}</p>`;
        quoteCard.innerHTML = `<p class="meta-muted" style="margin:0;">${String(error?.message || 'Не удалось рассчитать цену')}</p>`;
        setStatus(`Не удалось загрузить условия покупки: ${error?.message || 'unknown'}`);
      } finally {
        refreshBtn.disabled = false;
      }
    };

    amountInput.addEventListener('input', updateQuote);
    recipientInput.addEventListener('input', updateQuote);
    sameWalletCheckbox?.addEventListener('change', () => {
      setRecipientFromWallet();
      updateQuote();
    });

    helpBtn?.addEventListener('click', () => {
      void renderSupportHelp(renderSupportBuy);
    });

    refreshBtn?.addEventListener('click', () => {
      void refreshCore();
    });

    buyBtn?.addEventListener('click', async () => {
      buyBtn.disabled = true;
      try {
        if (!currentCore) {
          currentCore = await loadSupportPaymentsCore(state.entrySettings.solanaServer);
        }
        if (!walletCtx) {
          walletCtx = await getWalletFromStoredClientKey(sessionArgsOrThrow());
          walletAddress = walletCtx.address;
        }
        setRecipientFromWallet();
        const queue = queueStateView(currentCore.queues, 1);
        const remainingUsdCents = currentCore.coef.limitUsdCents > queue.sumTotalUsdCents
          ? currentCore.coef.limitUsdCents - queue.sumTotalUsdCents
          : 0n;
        const amountUsd = String(amountInput.value || '').trim().replace(',', '.');
        const amountUsdNumber = Number(amountUsd);
        if (!Number.isFinite(amountUsdNumber) || amountUsdNumber <= 0) {
          throw new Error('Введите корректную сумму в долларах.');
        }
        const amountUsdCents = BigInt(Math.round(amountUsdNumber * 100));
        if (amountUsdCents > remainingUsdCents) {
          throw new Error('Сумма превышает остаток текущего лимита. Уменьшите сумму или дождитесь нового лимита.');
        }
        const recipientWallet = String(recipientInput.value || '').trim() || walletAddress;
        if (!recipientWallet) throw new Error('Не указан кошелёк получателя.');
        const solana = await loadSolanaWeb3();
        const recipientPubkey = new solana.PublicKey(recipientWallet);
        const payLamports = (amountUsdCents * LAMPORTS_PER_SOL * currentCore.pyth.priceDen + currentCore.pyth.priceNum - 1n) / currentCore.pyth.priceNum;
        const maxPayLamports = (payLamports * 103n + 99n) / 100n;
        const nextIndex = queue.ticketsTotal + 1n;
        const [ticketPda] = solana.PublicKey.findProgramAddressSync(
          [utf8Bytes(SHINE_PAYMENTS_SEEDS.q1), u64ToBytes(nextIndex)],
          currentCore.programId,
        );
        const data = concatBytes(
          new Uint8Array([5]),
          u64ToBytes(amountUsdCents),
          u64ToBytes(maxPayLamports),
          recipientPubkey.toBytes(),
        );
        const ix = new solana.TransactionInstruction({
          programId: currentCore.programId,
          keys: [
            { pubkey: walletCtx.keypair.publicKey, isSigner: true, isWritable: true },
            { pubkey: currentCore.configPda, isSigner: false, isWritable: true },
            { pubkey: currentCore.coefPda, isSigner: false, isWritable: true },
            { pubkey: currentCore.queuesPda, isSigner: false, isWritable: true },
            { pubkey: ticketPda, isSigner: false, isWritable: true },
            { pubkey: new solana.PublicKey(currentCore.config.daoWallet), isSigner: false, isWritable: true },
            { pubkey: currentCore.oracleAccount, isSigner: false, isWritable: false },
            { pubkey: solana.SystemProgram.programId, isSigner: false, isWritable: false },
          ],
          data,
        });
        const connection = new solana.Connection(String(state.entrySettings.solanaServer || '').trim(), 'confirmed');
        const tx = new solana.Transaction().add(ix);
        tx.feePayer = walletCtx.keypair.publicKey;
        const bh = await connection.getLatestBlockhash('confirmed');
        tx.recentBlockhash = bh.blockhash;
        tx.partialSign(walletCtx.keypair);
        const signature = await connection.sendRawTransaction(tx.serialize(), { skipPreflight: false });
        await connection.confirmTransaction(
          { signature, blockhash: bh.blockhash, lastValidBlockHeight: bh.lastValidBlockHeight },
          'confirmed',
        );
        const ticketInfo = await connection.getAccountInfo(ticketPda, 'confirmed');
        const ticket = ticketInfo?.data
          ? parsePaymentsTicket(ticketInfo.data)
          : { index: nextIndex, queueId: 1, recipientWallet, payoutUsdCents: amountUsdCents };
        if (modeToken !== activeModeToken) return;
        setStatus(`Билет ${formatQueuePrefix(ticket.queueId)}-${ticket.index.toString()} куплен. Сохраните номер билета и secret key используемого кошелька.`);
        purchaseResultCard.innerHTML = `
          <div><b>Покупка завершена:</b> билет ${formatQueuePrefix(ticket.queueId)}-${ticket.index.toString()}</div>
          <div><b>Получатель:</b> <span style="word-break:break-all;">${ticket.recipientWallet}</span></div>
          <div><b>Сумма билета:</b> ${formatUsdCentsText(ticket.payoutUsdCents)} USD</div>
          <div><b>До него было в очереди:</b> ${ticket.index > 0n ? (ticket.index - 1n).toString() : '0'} билетов</div>
          <div><b>Транзакция:</b> <span style="word-break:break-all;">${signature}</span></div>
        `;
        await refreshCore();
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        setStatus(`Не удалось купить билет: ${error?.message || 'unknown'}`);
      } finally {
        buyBtn.disabled = false;
      }
    });

    content.append(
      backBtn,
      helpCard,
      stateCard,
      amountLabel,
      amountInput,
      recipientWrap,
      sameWalletRow,
      quoteCard,
      purchaseResultCard,
      actions,
    );

    if (!walletCtx) {
      try {
        walletCtx = await getWalletFromStoredClientKey(sessionArgsOrThrow());
        walletAddress = walletCtx.address;
        if (modeToken !== activeModeToken) return;
        setRecipientFromWallet();
      } catch (error) {
        setStatus(`Не удалось загрузить client.key: ${error?.message || 'unknown'}`);
      }
    }

    await refreshCore();
  }

  function renderWalletChoice() {
    activeModeToken += 1;
    clearArweaveSecretsInMemory();
    content.innerHTML = '';

    const card = document.createElement('div');
    card.className = 'card stack';
    card.innerHTML = `
      <h2 style="margin:0 0 6px;">Кошелёк</h2>
      <p class="meta-muted">Выберите режим кошелька.</p>
    `;

    const solanaBtn = document.createElement('button');
    solanaBtn.className = 'primary-btn';
    solanaBtn.style.width = '100%';
    solanaBtn.textContent = 'Solana кошелёк';
    solanaBtn.addEventListener('click', () => {
      void renderSolanaWallet();
    });

    const arweaveBtn = document.createElement('button');
    arweaveBtn.className = 'primary-btn';
    arweaveBtn.style.width = '100%';
    arweaveBtn.textContent = 'Arweave кошелёк';
    arweaveBtn.addEventListener('click', () => {
      void renderArweaveWallet();
    });

    const shineBchBtn = document.createElement('button');
    shineBchBtn.className = 'primary-btn';
    shineBchBtn.style.width = '100%';
    shineBchBtn.textContent = 'Блокчейн Сияния';
    shineBchBtn.addEventListener('click', () => {
      void renderShineBlockchainWallet();
    });

    const supportBtn = document.createElement('button');
    supportBtn.className = 'primary-btn';
    supportBtn.style.width = '100%';
    supportBtn.textContent = 'Поддержать проект Сияние';
    supportBtn.addEventListener('click', () => {
      void renderSupportHub();
    });

    card.append(solanaBtn, arweaveBtn, shineBchBtn, supportBtn);
    content.append(card);
    setStatus('Выберите тип кошелька.');
  }

  async function renderShineBlockchainWallet() {
    const modeToken = ++activeModeToken;
    clearArweaveSecretsInMemory();
    content.innerHTML = '';

    const backBtn = createModeBackButton(renderWalletChoice);
    const card = document.createElement('div');
    card.className = 'card stack';

    const limitLabel = document.createElement('p');
    limitLabel.className = 'meta-muted';
    limitLabel.textContent = 'Лимит блокчейна';
    const limitValue = document.createElement('h2');
    limitValue.style.fontSize = '26px';
    limitValue.textContent = '— KB';

    const usedLabel = document.createElement('p');
    usedLabel.className = 'meta-muted';
    usedLabel.textContent = 'Израсходовано (фактически на сервере)';
    const usedValue = document.createElement('h2');
    usedValue.style.fontSize = '26px';
    usedValue.textContent = '— KB';

    const leftLabel = document.createElement('p');
    leftLabel.className = 'meta-muted';
    leftLabel.textContent = 'Осталось';
    const leftValue = document.createElement('h2');
    leftValue.style.fontSize = '30px';
    leftValue.textContent = '— KB';

    const pdaLabel = document.createElement('p');
    pdaLabel.className = 'meta-muted';
    pdaLabel.style.wordBreak = 'break-all';
    pdaLabel.textContent = 'PDA: —';

    const endpointLabel = document.createElement('p');
    endpointLabel.className = 'meta-muted';
    endpointLabel.textContent = `RPC: ${state.entrySettings.solanaServer}`;

    const updatedLabel = document.createElement('p');
    updatedLabel.className = 'meta-muted';
    updatedLabel.textContent = 'Обновлено: —';

    const serverTitle = document.createElement('h3');
    serverTitle.style.margin = '14px 0 0';
    serverTitle.textContent = 'Фактическое состояние на сервере';
    const serverSizeLabel = document.createElement('p');
    serverSizeLabel.className = 'meta-muted';
    serverSizeLabel.textContent = 'Размер цепочки: —';
    const serverLastLabel = document.createElement('p');
    serverLastLabel.className = 'meta-muted';
    serverLastLabel.textContent = 'Крайний блок: —';
    const serverLastHashLabel = document.createElement('p');
    serverLastHashLabel.className = 'meta-muted';
    serverLastHashLabel.style.wordBreak = 'break-all';
    serverLastHashLabel.style.fontSize = '11px';
    serverLastHashLabel.textContent = 'Hash: —';

    const solanaTitle = document.createElement('h3');
    solanaTitle.style.margin = '14px 0 0';
    solanaTitle.textContent = 'Закреплено в Solana';
    const solanaLastLabel = document.createElement('p');
    solanaLastLabel.className = 'meta-muted';
    solanaLastLabel.textContent = 'Крайний блок: —';
    const solanaLastHashLabel = document.createElement('p');
    solanaLastHashLabel.className = 'meta-muted';
    solanaLastHashLabel.style.wordBreak = 'break-all';
    solanaLastHashLabel.style.fontSize = '11px';
    solanaLastHashLabel.textContent = 'Hash: —';

    card.append(
      limitLabel,
      limitValue,
      usedLabel,
      usedValue,
      leftLabel,
      leftValue,
      pdaLabel,
      endpointLabel,
      updatedLabel,
      serverTitle,
      serverSizeLabel,
      serverLastLabel,
      serverLastHashLabel,
      solanaTitle,
      solanaLastLabel,
      solanaLastHashLabel,
    );

    const actions = document.createElement('div');
    actions.className = 'stack';
    actions.innerHTML = `
      <button class="ghost-btn" id="refresh-shine-bch" style="width:100%;">Обновить</button>
      <button class="primary-btn" id="sync-shine-solana" style="width:100%;">Закрепить в Solana</button>
      <button class="primary-btn" id="topup-shine-limit" style="width:100%;">Увеличить лимит</button>
    `;
    const refreshBtn = actions.querySelector('#refresh-shine-bch');
    const syncBtn = actions.querySelector('#sync-shine-solana');
    const topupBtn = actions.querySelector('#topup-shine-limit');

    const fetchServerState = async () => {
      const user = await authService.getUser(String(state.session.login || '').trim());
      if (!user?.exists) throw new Error('Пользователь не найден на сервере');
      const lastNumber = Number(user.serverLastGlobalNumber ?? -1);
      return {
        sizeBytes: Number(user.serverBlockchainSizeBytes || 0),
        sizeLimitBytes: Number(user.serverBlockchainSizeLimitBytes || 0),
        lastNumber,
        lastHash: String(user.serverLastGlobalHash || ''),
      };
    };

    const resolveWalletSigningMaterial = async () => {
      const { login, storagePwd } = sessionArgsOrThrow();
      let saved;
      try {
        saved = await loadEncryptedUserSecrets(login, storagePwd);
      } catch {
        saved = null;
      }
      let rootKey = String(saved?.rootKey || '').trim();
      let blockchainKey = String(saved?.blockchainKey || '').trim();
      const clientKey = String(saved?.clientKey || '').trim();
      if (!clientKey) throw new Error('На устройстве нет client.key. Выполните вход заново.');
      if (rootKey && blockchainKey) {
        return { rootPrivatePkcs8B64: rootKey, blockchainPrivatePkcs8B64: blockchainKey, clientPrivatePkcs8B64: clientKey };
      }

      const password = window.prompt(
        'Для операции нужен root key (и blockchain key), но они не сохранены на устройстве.\nВведите пароль аккаунта для временного восстановления ключей:',
        '',
      );
      if (password == null) throw new Error('Операция отменена пользователем');
      const keyBundle = await authService.derivePasswordKeyBundle(login, password);
      rootKey = keyBundle?.rootPair?.privatePkcs8B64 || '';
      blockchainKey = keyBundle?.blockchainPair?.privatePkcs8B64 || '';
      if (!rootKey || !blockchainKey) throw new Error('Не удалось восстановить root/blockchain key из пароля');

      const shouldSave = window.confirm(
        'Сохранить root key и blockchain key в зашифрованном контейнере этого устройства?\nВнимание: хранить ключи на телефоне менее безопасно.',
      );
      if (shouldSave) {
        await authService.persistSelectedKeys(login, storagePwd, keyBundle, { saveRoot: true, saveBlockchain: true });
      }
      return { rootPrivatePkcs8B64: rootKey, blockchainPrivatePkcs8B64: blockchainKey, clientPrivatePkcs8B64: clientKey };
    };

    const setButtonsDisabled = (disabled) => {
      refreshBtn.disabled = disabled;
      syncBtn.disabled = disabled;
      topupBtn.disabled = disabled;
    };

    const refreshUsage = async () => {
      setButtonsDisabled(true);
      try {
        const [usage, serverState] = await Promise.all([
          getShineBlockchainUsage({
            login: String(state.session.login || '').trim(),
            solanaEndpoint: state.entrySettings.solanaServer,
          }),
          fetchServerState(),
        ]);
        if (modeToken !== activeModeToken) return;
        limitValue.textContent = formatKbFromBytes(usage.paidLimitBytes);
        const usedServerBytes = BigInt(Math.max(0, Number(serverState.sizeBytes || 0)));
        const leftServerBytes = usage.paidLimitBytes > usedServerBytes ? (usage.paidLimitBytes - usedServerBytes) : 0n;
        usedValue.textContent = formatKbFromBytes(usedServerBytes);
        leftValue.textContent = formatKbFromBytes(leftServerBytes);
        pdaLabel.textContent = `PDA: ${usage.userPda}`;
        endpointLabel.textContent = `RPC: ${usage.endpoint}`;
        updatedLabel.textContent = `Обновлено: ${nowRu()}`;

        serverSizeLabel.textContent = `Размер цепочки: ${formatKbFromBytes(serverState.sizeBytes)}`;
        serverLastLabel.textContent = `Крайний блок: ${serverState.lastNumber}`;
        serverLastHashLabel.textContent = `Hash: ${serverState.lastHash || '—'}`;

        solanaLastLabel.textContent = `Крайний блок: ${usage.lastBlockNumber}`;
        solanaLastHashLabel.textContent = `Hash: ${usage.lastBlockHashHex || '—'}`;

        setStatus('Данные лимита и состояния блокчейна обновлены.');
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        setStatus(`Не удалось обновить состояние блокчейна: ${error?.message || 'unknown'}`);
      } finally {
        setButtonsDisabled(false);
      }
    };

    syncBtn.addEventListener('click', async () => {
      setButtonsDisabled(true);
      try {
        const [serverState, signing] = await Promise.all([
          fetchServerState(),
          resolveWalletSigningMaterial(),
        ]);
        const result = await updateShineUserPdaOnSolana({
          login: String(state.session.login || '').trim(),
          solanaEndpoint: state.entrySettings.solanaServer,
          rootPrivatePkcs8B64: signing.rootPrivatePkcs8B64,
          blockchainPrivatePkcs8B64: signing.blockchainPrivatePkcs8B64,
          clientPrivatePkcs8B64: signing.clientPrivatePkcs8B64,
          additionalLimitBytes: 0n,
          nextUsedBytes: BigInt(Math.max(0, serverState.sizeBytes)),
          nextLastBlockNumber: serverState.lastNumber,
          nextLastBlockHashHex: serverState.lastHash,
        });
        if (modeToken !== activeModeToken) return;
        setStatus(`Состояние закреплено в Solana. Tx: ${result.signature}`);
        await refreshUsage();
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        setStatus(`Не удалось закрепить состояние в Solana: ${error?.message || 'unknown'}`);
      } finally {
        setButtonsDisabled(false);
      }
    });

    topupBtn.addEventListener('click', async () => {
      setButtonsDisabled(true);
      try {
        const economy = await getShineUsersEconomyConfig({ solanaEndpoint: state.entrySettings.solanaServer });
        const step = getLimitStepBytes();
        const input = window.prompt(
          `Введите, на сколько увеличить лимит (в байтах, шаг ${step.toString()}).\nЦена за шаг: ${lamportsToSolText(economy.lamportsPerLimitStep)} SOL`,
          step.toString(),
        );
        if (!input) {
          setStatus('Увеличение лимита отменено.');
          return;
        }
        const addBytes = BigInt(String(input).trim());
        const priceLamports = calcLimitTopupPriceLamports(addBytes, economy.lamportsPerLimitStep);
        const confirm = window.confirm(
          `Будет увеличено на ${formatKbFromBytes(addBytes)}.\n` +
          `С вашего Solana-счёта будет списано ~${lamportsToSolText(priceLamports)} SOL.\n` +
          `Продолжить?`,
        );
        if (!confirm) {
          setStatus('Увеличение лимита отменено.');
          return;
        }
        const signing = await resolveWalletSigningMaterial();
        const result = await updateShineUserPdaOnSolana({
          login: String(state.session.login || '').trim(),
          solanaEndpoint: state.entrySettings.solanaServer,
          rootPrivatePkcs8B64: signing.rootPrivatePkcs8B64,
          blockchainPrivatePkcs8B64: signing.blockchainPrivatePkcs8B64,
          clientPrivatePkcs8B64: signing.clientPrivatePkcs8B64,
          additionalLimitBytes: addBytes,
        });
        if (modeToken !== activeModeToken) return;
        setStatus(`Лимит увеличен. Tx: ${result.signature}`);
        await refreshUsage();
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        setStatus(`Не удалось увеличить лимит: ${error?.message || 'unknown'}`);
      } finally {
        setButtonsDisabled(false);
      }
    });

    refreshBtn.addEventListener('click', () => {
      void refreshUsage();
    });

    content.append(backBtn, card, actions);
    setStatus('Загрузка данных блокчейна Сияния...');
    await refreshUsage();
  }

  async function renderSolanaWallet() {
    const modeToken = ++activeModeToken;
    clearArweaveSecretsInMemory();
    content.innerHTML = '';

    let walletCtx = null;
    let walletAddress = '';

    const backBtn = createModeBackButton(renderWalletChoice);

    const card = document.createElement('div');
    card.className = 'card stack';

    const balanceWrap = document.createElement('div');
    const balanceLabel = document.createElement('p');
    balanceLabel.className = 'meta-muted';
    balanceLabel.textContent = 'Баланс (Solana)';
    const balanceValue = document.createElement('h2');
    balanceValue.style.fontSize = '30px';
    balanceValue.textContent = '— SOL';
    const updatedLabel = document.createElement('p');
    updatedLabel.className = 'meta-muted';
    updatedLabel.textContent = 'Обновлено: —';
    const endpointLabel = document.createElement('p');
    endpointLabel.className = 'meta-muted';
    endpointLabel.textContent = `RPC: ${state.entrySettings.solanaServer}`;
    balanceWrap.append(balanceLabel, balanceValue, updatedLabel, endpointLabel);

    const addressCard = document.createElement('div');
    addressCard.className = 'card';
    addressCard.style.padding = '10px';
    addressCard.innerHTML = `
      <p class="meta-muted" style="margin-bottom:6px;">Публичный адрес (client.key)</p>
      <p style="font-size:13px; line-height:1.4; word-break:break-all;" id="wallet-address-value">—</p>
    `;
    const addressEl = addressCard.querySelector('#wallet-address-value');

    card.append(balanceWrap, addressCard);

    const actions = document.createElement('div');
    actions.className = 'stack';
    actions.innerHTML = `
      <div class="row">
        <button class="text-btn" id="copy-address">Копировать адрес</button>
        <button class="ghost-btn" id="refresh-balance">Обновить баланс</button>
      </div>
      <div class="row">
        <button class="primary-btn" id="send-sol" style="width:100%;">Перевести</button>
        <button class="primary-btn" id="topup-sol" style="width:100%;">Пополнить</button>
      </div>
    `;

    const copyBtn = actions.querySelector('#copy-address');
    const refreshBtn = actions.querySelector('#refresh-balance');
    const sendBtn = actions.querySelector('#send-sol');
    const topupBtn = actions.querySelector('#topup-sol');

    const generatedCard = document.createElement('div');
    generatedCard.className = 'card stack';
    generatedCard.innerHTML = `
      <h3 style="margin:0;">Создание нового кошелька Solana</h3>
      <p class="meta-muted" style="margin:0;">Введите приватный ключ Base58 (32 байта) или сгенерируйте случайный.</p>
    `;

    const privateLabel = document.createElement('label');
    privateLabel.className = 'meta-muted';
    privateLabel.textContent = 'Приватный ключ (Base58, 32 байта)';
    privateLabel.setAttribute('for', 'solana-private-base58-input');

    const privateInput = document.createElement('input');
    privateInput.id = 'solana-private-base58-input';
    privateInput.type = 'text';
    privateInput.placeholder = 'Введите приватный ключ Base58';
    privateInput.maxLength = SOLANA_PRIVATE_BASE58_MAX_LEN;
    privateInput.autocomplete = 'off';
    privateInput.spellcheck = false;

    const privateState = document.createElement('p');
    privateState.className = 'meta-muted';
    privateState.textContent = 'Ожидается Base58-строка приватного ключа.';

    const generatedPublicLabel = document.createElement('label');
    generatedPublicLabel.className = 'meta-muted';
    generatedPublicLabel.textContent = 'Публичный ключ (Base58)';
    generatedPublicLabel.setAttribute('for', 'solana-generated-public-key');

    const generatedPublicInput = document.createElement('input');
    generatedPublicInput.id = 'solana-generated-public-key';
    generatedPublicInput.type = 'text';
    generatedPublicInput.readOnly = true;
    generatedPublicInput.placeholder = 'Будет сгенерирован после нажатия кнопки';

    const generatedPrivateLabel = document.createElement('label');
    generatedPrivateLabel.className = 'meta-muted';
    generatedPrivateLabel.textContent = 'Сгенерированный приватный ключ (Base58)';
    generatedPrivateLabel.setAttribute('for', 'solana-generated-private-key');

    const generatedPrivateInput = document.createElement('input');
    generatedPrivateInput.id = 'solana-generated-private-key';
    generatedPrivateInput.type = 'text';
    generatedPrivateInput.readOnly = true;
    generatedPrivateInput.placeholder = 'Появится после генерации';

    const generationActions = document.createElement('div');
    generationActions.className = 'row';
    generationActions.innerHTML = `
      <button class="primary-btn" id="generate-random-solana" style="width:100%;">Сгенерировать случайный кошелёк</button>
      <button class="primary-btn" id="generate-from-private-solana" style="width:100%;">Сгенерировать из приватного ключа</button>
    `;

    const copyGeneratedActions = document.createElement('div');
    copyGeneratedActions.className = 'row';
    copyGeneratedActions.innerHTML = `
      <button class="text-btn" id="copy-generated-private-solana" style="width:100%;">Копировать приватный</button>
      <button class="text-btn" id="copy-generated-public-solana" style="width:100%;">Копировать публичный</button>
    `;

    generatedCard.append(
      privateLabel,
      privateInput,
      privateState,
      generationActions,
      generatedPrivateLabel,
      generatedPrivateInput,
      generatedPublicLabel,
      generatedPublicInput,
      copyGeneratedActions,
    );

    const randomGenerateBtn = generationActions.querySelector('#generate-random-solana');
    const fromPrivateGenerateBtn = generationActions.querySelector('#generate-from-private-solana');
    const copyGeneratedPrivateBtn = copyGeneratedActions.querySelector('#copy-generated-private-solana');
    const copyGeneratedPublicBtn = copyGeneratedActions.querySelector('#copy-generated-public-solana');

    const BASE58_RE = /^[1-9A-HJ-NP-Za-km-z]+$/;
    const validatePrivateInput = () => {
      const value = String(privateInput.value || '').trim();
      if (!value) {
        privateState.textContent = 'Ожидается Base58-строка приватного ключа.';
        return false;
      }
      if (!BASE58_RE.test(value)) {
        privateState.textContent = 'Недопустимый формат: используйте только Base58.';
        return false;
      }
      if (value.length > SOLANA_PRIVATE_BASE58_MAX_LEN) {
        privateState.textContent = 'Слишком длинное значение.';
        return false;
      }
      try {
        const alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
        let num = 0n;
        for (const c of value) {
          num = num * 58n + BigInt(alphabet.indexOf(c));
        }
        let hex = num.toString(16);
        if (hex.length % 2) hex = `0${hex}`;
        const decoded = hex ? hex.match(/.{1,2}/g)?.map((h) => parseInt(h, 16)) || [] : [];
        let leadingZeros = 0;
        while (leadingZeros < value.length && value[leadingZeros] === '1') leadingZeros += 1;
        const byteLen = leadingZeros + decoded.length;
        if (byteLen < 32) {
          privateState.textContent = 'Слишком короткое значение: нужно 32 байта.';
          return false;
        }
        if (byteLen > 32) {
          privateState.textContent = 'Слишком длинное значение: нужно ровно 32 байта.';
          return false;
        }
      } catch {
        privateState.textContent = 'Ошибка декодирования Base58.';
        return false;
      }
      privateState.textContent = 'Подходит';
      return true;
    };

    privateInput.addEventListener('input', () => {
      validatePrivateInput();
    });

    const setGenerationDisabled = (disabled) => {
      randomGenerateBtn.disabled = disabled;
      fromPrivateGenerateBtn.disabled = disabled;
      copyGeneratedPrivateBtn.disabled = disabled;
      copyGeneratedPublicBtn.disabled = disabled;
    };

    randomGenerateBtn.addEventListener('click', async () => {
      setGenerationDisabled(true);
      try {
        const generated = await createRandomSolanaWallet();
        if (modeToken !== activeModeToken) return;
        generatedPrivateInput.value = generated.privateKey32Base58;
        generatedPublicInput.value = generated.address;
        privateState.textContent = 'Случайный кошелёк создан.';
        setStatus('Случайный кошелёк Solana успешно сгенерирован.');
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        setStatus(`Ошибка генерации случайного кошелька: ${error?.message || 'unknown'}`);
      } finally {
        setGenerationDisabled(false);
      }
    });

    fromPrivateGenerateBtn.addEventListener('click', async () => {
      if (!validatePrivateInput()) {
        setStatus('Исправьте приватный ключ перед генерацией.');
        return;
      }
      setGenerationDisabled(true);
      try {
        const generated = await createSolanaWalletFromPrivateBase58(privateInput.value);
        if (modeToken !== activeModeToken) return;
        generatedPrivateInput.value = generated.privateKey32Base58;
        generatedPublicInput.value = generated.address;
        privateState.textContent = 'Подходит';
        setStatus('Публичный ключ сгенерирован из введённого приватного ключа.');
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        setStatus(`Ошибка генерации из приватного ключа: ${error?.message || 'unknown'}`);
      } finally {
        setGenerationDisabled(false);
      }
    });

    copyGeneratedPrivateBtn.addEventListener('click', async () => {
      const value = String(generatedPrivateInput.value || '').trim();
      if (!value) {
        setStatus('Сначала сгенерируйте приватный ключ.');
        return;
      }
      try {
        await navigator.clipboard.writeText(value);
        setStatus('Приватный ключ скопирован.');
      } catch {
        setStatus('Не удалось скопировать приватный ключ в этом браузере.');
      }
    });

    copyGeneratedPublicBtn.addEventListener('click', async () => {
      const value = String(generatedPublicInput.value || '').trim();
      if (!value) {
        setStatus('Сначала сгенерируйте публичный ключ.');
        return;
      }
      try {
        await navigator.clipboard.writeText(value);
        setStatus('Публичный ключ скопирован.');
      } catch {
        setStatus('Не удалось скопировать публичный ключ в этом браузере.');
      }
    });

    const refreshBalance = async () => {
      if (!walletAddress) {
        setStatus('Кошелёк не инициализирован.');
        return;
      }
      refreshBtn.disabled = true;
      try {
        const balance = await getBalanceSol({
          endpoint: state.entrySettings.solanaServer,
          address: walletAddress,
        });
        if (modeToken !== activeModeToken) return;
        balanceValue.textContent = `${formatSol(balance.sol, 6)} SOL`;
        updatedLabel.textContent = `Обновлено: ${nowRu()}`;
        endpointLabel.textContent = `RPC: ${balance.endpoint}`;
        setStatus('Баланс обновлён.');
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        setStatus(`Не удалось получить баланс: ${error?.message || 'unknown'}`);
      } finally {
        refreshBtn.disabled = false;
      }
    };

    copyBtn.addEventListener('click', async () => {
      if (!walletAddress) return;
      try {
        await navigator.clipboard.writeText(walletAddress);
        setStatus('Адрес скопирован в буфер обмена');
      } catch {
        setStatus('Не удалось скопировать адрес в этом браузере');
      }
    });

    refreshBtn.addEventListener('click', () => {
      void refreshBalance();
    });

    sendBtn.addEventListener('click', async () => {
      if (!walletCtx?.keypair) {
        setStatus('Перевод недоступен: client.key не загружен.');
        return;
      }
      const toAddress = window.prompt('Введите адрес получателя (Solana):', '');
      if (!toAddress) return;
      const amountRaw = window.prompt('Введите сумму SOL для перевода:', '0.01');
      if (!amountRaw) return;

      sendBtn.disabled = true;
      try {
        const tx = await transferSol({
          endpoint: state.entrySettings.solanaServer,
          fromKeypair: walletCtx.keypair,
          toAddress,
          amountSol: Number(String(amountRaw || '').replace(',', '.')),
        });
        if (modeToken !== activeModeToken) return;
        setStatus(`Перевод отправлен. Signature: ${tx.signature}`);
        await refreshBalance();
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        setStatus(`Ошибка перевода: ${error?.message || 'unknown'}`);
      } finally {
        sendBtn.disabled = false;
      }
    });

    topupBtn.addEventListener('click', async () => {
      if (!walletAddress) {
        setStatus('Кошелёк не инициализирован.');
        return;
      }
      window.location.assign(getTopupSiteUrl(walletAddress));
    });

    content.append(backBtn, card, actions, generatedCard);
    setStatus('Инициализация client.key...');

    try {
      walletCtx = await getWalletFromStoredClientKey(sessionArgsOrThrow());
      if (modeToken !== activeModeToken) return;
      walletAddress = walletCtx.address;
      addressEl.textContent = walletAddress;
      await refreshBalance();
    } catch (error) {
      if (modeToken !== activeModeToken) return;
      addressEl.textContent = 'client.key недоступен';
      setStatus(`Не удалось инициализировать кошелёк: ${error?.message || 'unknown'}`);
    }
  }

  async function renderArweaveWallet() {
    const modeToken = ++activeModeToken;
    content.innerHTML = '';

    let walletAddress = '';

    const backBtn = createModeBackButton(renderWalletChoice);

    const card = document.createElement('div');
    card.className = 'card stack';

    const balanceWrap = document.createElement('div');
    const balanceLabel = document.createElement('p');
    balanceLabel.className = 'meta-muted';
    balanceLabel.textContent = 'Баланс (Arweave)';
    const balanceValue = document.createElement('h2');
    balanceValue.style.fontSize = '30px';
    balanceValue.textContent = '— AR';
    const updatedLabel = document.createElement('p');
    updatedLabel.className = 'meta-muted';
    updatedLabel.textContent = 'Обновлено: —';
    const gatewayLabel = document.createElement('p');
    gatewayLabel.className = 'meta-muted';
    gatewayLabel.textContent = `Gateway: ${state.entrySettings.arweaveServer}`;
    balanceWrap.append(balanceLabel, balanceValue, updatedLabel, gatewayLabel);

    const addressCard = document.createElement('div');
    addressCard.className = 'card';
    addressCard.style.padding = '10px';
    addressCard.innerHTML = `
      <p class="meta-muted" style="margin-bottom:6px;">Публичный адрес Arweave (SAWD-v1)</p>
      <p style="font-size:13px; line-height:1.4; word-break:break-all;" id="wallet-address-value">—</p>
    `;
    const addressEl = addressCard.querySelector('#wallet-address-value');

    const helpCard = document.createElement('details');
    helpCard.className = 'card';
    helpCard.style.padding = '10px';
    helpCard.innerHTML = `
      <summary style="cursor:pointer; font-weight:600;">Как получен этот адрес?</summary>
      <p class="meta-muted" style="margin-top:8px;">
        SHiNE берёт ваш локальный client.key и по стандарту SAWD-v1 получает из него нативный Arweave-кошелёк.
        Приватный ключ не отправляется на сервер. После первого расчёта он хранится только в зашифрованном контейнере этого устройства.
      </p>
    `;

    card.append(balanceWrap, addressCard, helpCard);

    const actions = document.createElement('div');
    actions.className = 'stack';
    actions.innerHTML = `
      <div class="row">
        <button class="text-btn" id="copy-address">Копировать адрес</button>
        <button class="ghost-btn" id="refresh-balance">Обновить баланс</button>
      </div>
      <div class="row">
        <button class="primary-btn" id="send-ar" style="width:100%;">Перевести</button>
        <button class="primary-btn" id="topup-ar" style="width:100%;">Пополнить</button>
      </div>
    `;

    const copyBtn = actions.querySelector('#copy-address');
    const refreshBtn = actions.querySelector('#refresh-balance');
    const sendBtn = actions.querySelector('#send-ar');
    const topupBtn = actions.querySelector('#topup-ar');

    const refreshBalance = async () => {
      if (!walletAddress) {
        setStatus('Arweave-кошелёк не инициализирован.');
        return;
      }
      refreshBtn.disabled = true;
      try {
        const balance = await getArweaveBalance({
          gateway: state.entrySettings.arweaveServer,
          address: walletAddress,
        });
        if (modeToken !== activeModeToken) return;
        balanceValue.textContent = `${formatAr(balance.ar, 6)} AR`;
        updatedLabel.textContent = `Обновлено: ${nowRu()}`;
        gatewayLabel.textContent = `Gateway: ${balance.gateway}`;
        setStatus('Баланс обновлён.');
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        setStatus(`Не удалось получить баланс: ${error?.message || 'unknown'}`);
      } finally {
        refreshBtn.disabled = false;
      }
    };

    copyBtn.addEventListener('click', async () => {
      if (!walletAddress) return;
      try {
        await navigator.clipboard.writeText(walletAddress);
        setStatus('Адрес скопирован');
      } catch {
        setStatus('Не удалось скопировать адрес в этом браузере');
      }
    });

    refreshBtn.addEventListener('click', () => {
      void refreshBalance();
    });

    sendBtn.addEventListener('click', async () => {
      if (!arweaveWalletCtx?.jwk) {
        setStatus('Перевод недоступен: Arweave-кошелёк не инициализирован.');
        return;
      }
      const toAddress = window.prompt('Введите адрес получателя (Arweave):', '');
      if (!toAddress) return;
      const amountRaw = window.prompt('Введите сумму AR для перевода:', '0.01');
      if (!amountRaw) return;

      sendBtn.disabled = true;
      try {
        const tx = await transferAr({
          gateway: state.entrySettings.arweaveServer,
          jwk: arweaveWalletCtx.jwk,
          toAddress,
          amountAr: amountRaw,
        });
        if (modeToken !== activeModeToken) return;
        setStatus(`Перевод отправлен. Transaction ID: ${tx.id}`);
        await refreshBalance();
      } catch (error) {
        if (modeToken !== activeModeToken) return;
        setStatus(`Ошибка перевода: ${error?.message || 'unknown'}`);
      } finally {
        sendBtn.disabled = false;
      }
    });

    topupBtn.addEventListener('click', () => {
      window.open(getArweaveTopupSiteUrl(), '_blank', 'noopener,noreferrer');
      setStatus('Открыта страница пополнения.');
    });

    content.append(backBtn, card, actions);
    setStatus('Генерация Arweave-кошелька...');

    try {
      let wasFirstTimeGeneration = false;
      arweaveWalletCtx = await getArweaveWalletFromStoredClientKey({
        ...sessionArgsOrThrow(),
        onStatus: (message) => {
          const text = String(message || '').trim();
          if (!text) return;
          if (text.includes('впервые получаем Arweave-кошелёк')) {
            wasFirstTimeGeneration = true;
            setStatus('Подождите — ваш Arweave-ключ вычисляется из client key. Это происходит только один раз, потом будет мгновенно.');
            return;
          }
          setStatus(text);
        },
      });
      if (modeToken !== activeModeToken) return;
      if (wasFirstTimeGeneration) setStatus('');
      walletAddress = arweaveWalletCtx.address;
      addressEl.textContent = walletAddress;
      await refreshBalance();
    } catch (error) {
      if (modeToken !== activeModeToken) return;
      addressEl.textContent = 'client.key недоступен';
      clearArweaveSecretsInMemory();
      setStatus(`Не удалось инициализировать Arweave-кошелёк: ${error?.message || 'unknown'}`);
    }
  }

  renderWalletChoice();
  return screen;
}