@xgamesfun/solana 0.0.0-stage → 0.24.0

package/js/approve/live-check.mjs

@@ -0,0 +1,144 @@
+// What the spec file's `live` section says is made, held against the chain before anything is built on it. The file is
+// written by agents, by hand and by teammates, so its `live` section is no more trusted than the rest of it: a planted
+// one could name someone else's project (the owner's seeds would pay into its pools) or another treasury. The project
+// must be the connected wallet's own, at the address its number makes, and the project, the mints, the collection and
+// the tree the file calls made must be on chain and be that project's.
+import { encodeBase58 } from '../chain/base58.js';
+import { parseCoreCollection, MPL_CORE_PROGRAM } from '../chain/core.js';
+import { parseMint } from '../chain/mint.js';
+import { mayStartFrozen } from '../chain/token2022.js';
+import { accountKind, decode } from '../client/accounts.js';
+import { BUBBLEGUM_PROGRAM, LOOT_PROGRAM, pda } from '../client/pda.js';
+import { SYSTEM_PROGRAM } from '../chain/pda.js';
+import { madeSoFar } from '../economy/plan.mjs';
+
+/** A `live` section that does not match the chain: the message says what differs, in plain words. */
+export class LiveMismatch extends Error {}
+
+/**
+ * Checks `live` (the spec's live section) for `wallet`, the wallet connected on the page, against `chain` ({ account }).
+ * `m` is the spec's model. Returns { owner, project }: the project's owner the setup is built for (the wallet, or the
+ * project's owner when the wallet is its authority), and the project's address. Throws LiveMismatch when the file
+ * names a project that is not this wallet's, or an account the chain does not have as the file says.
+ */
+export async function checkLive({ live, m, wallet, chain }) {
+  const made = madeSoFar(live) ?? {};
+  const own = pda.project(wallet, m.projectNumber);
+  const setupMints = Object.entries(made.mints ?? {}).filter(([key]) => {
+    const t = m.tokens.get(key);
+    // Only a mint the setup makes is checked: a mint the spec names by its address is the spec's to name.
+    return t?.source === 'game' && (!t.mint || t.mint.startsWith('@'));
+  });
+  if (!made.project && !setupMints.length && !made.collection && !made.tree) return { owner: wallet, project: own };
+  if (typeof chain.account !== 'function') throw new Error('The file says part of this economy is live already, and this connection cannot read the chain to check it: nothing was sent.');
+  const read = (address) => chain.account(address);
+
+  let owner = wallet;
+  let project = own;
+  if (made.project) {
+    const account = await read(made.project);
+    if (!account || account.owner !== LOOT_PROGRAM || accountKind(account.data) !== 'Project') throw new LiveMismatch(`The file names the project ${made.project}, and there is no loot project at that address.`);
+    const state = decode('Project', account.data);
+    if (pda.project(state.owner, m.projectNumber) !== made.project) throw new LiveMismatch(`The file names the project ${made.project}, which is not project number ${m.projectNumber} of its owner ${state.owner}.`);
+    if (state.owner !== wallet && state.authority !== wallet) throw new LiveMismatch(`The file names the project ${made.project}, which belongs to the wallet ${state.owner}, not to the connected wallet ${wallet}. Your own project number ${m.projectNumber} is at ${own}.`);
+    if (made.treasury && made.treasury !== state.treasury) throw new LiveMismatch(`The file says the treasury is ${made.treasury}; on chain it is ${state.treasury}.`);
+    if (made.authority && made.authority !== state.authority) throw new LiveMismatch(`The file says the authority is ${made.authority}; on chain it is ${state.authority}.`);
+    owner = state.owner;
+    project = made.project;
+  }
+
+  for (const [key, address] of setupMints) {
+    const t = m.tokens.get(key);
+    const account = await read(address);
+    const mint = account ? parseMint(address, account.owner, account.data) : null;
+    if (!mint) throw new LiveMismatch(`The file says the setup made the token ${t.symbol ?? key} at ${address}, and there is no mint there.`);
+    if (mint.decimals !== (t.decimals ?? 0)) throw new LiveMismatch(`The mint ${address} the file names for ${t.symbol ?? key} has ${mint.decimals} decimals, not ${t.decimals ?? 0}.`);
+    // The setup hands a token's minting to the project, or turns it off for good (a fixed supply); it never keeps a
+    // freeze authority.
+    const minter = t.fixedSupply ? null : project;
+    if (mint.mintAuthority !== minter) throw new LiveMismatch(`The mint ${address} the file names for ${t.symbol ?? key} is minted by ${mint.mintAuthority ?? 'nobody'}, not ${minter ?? 'nobody'} as the setup leaves it.`);
+    if (mint.freezeAuthority) throw new LiveMismatch(`The mint ${address} the file names for ${t.symbol ?? key} can be frozen by ${mint.freezeAuthority}; the setup makes none that can.`);
+  }
+
+  if (made.collection) {
+    const account = await read(made.collection);
+    let collection;
+    try {
+      collection = account?.owner === MPL_CORE_PROGRAM ? parseCoreCollection(account.data) : null;
+    } catch {
+      collection = null;
+    }
+    if (!collection) throw new LiveMismatch(`The file names the collection ${made.collection}, and there is no Core collection there.`);
+    if (collection.updateAuthority !== owner) throw new LiveMismatch(`The collection ${made.collection} the file names belongs to ${collection.updateAuthority}, not to the project's owner ${owner}.`);
+  }
+
+  if (made.tree) {
+    const config = await read(pda.treeConfig(made.tree));
+    const creator = config?.owner === BUBBLEGUM_PROGRAM && config.data.length >= 40 ? encodeBase58(config.data.subarray(8, 40)) : null;
+    if (creator !== project) throw new LiveMismatch(`The file names the tree ${made.tree}, which is not a tree of the project ${project}.`);
+  }
+  return { owner, project };
+}
+
+/** A token the spec names by its mint address that is not that mint on chain: the message says what differs. */
+export class MintMismatch extends Error {}
+
+/**
+ * Checks every token the spec names by its mint address (an existing token, or a game token on a mint of its own)
+ * against `chain` ({ account }): the mint must be there, of the token program the spec says, with the decimals the
+ * spec says. Every amount the page shows is written in base units with the spec's decimals, and the program takes them
+ * as they are, so one decimal off is ten times what the page says. A mint the setup makes is made with the spec's
+ * decimals, and is not read. Throws MintMismatch.
+ */
+export async function checkMints({ m, chain }) {
+  const named = [...m.tokens.values()].filter((t) => t.mint && !t.mint.startsWith('@'));
+  // The routes that read a mint's default account state once, as they open, and refuse one that can start frozen.
+  const once = new Map();
+  const reads = (key, what) => key && !once.has(key) && once.set(key, what);
+  for (const l of m.lotteries) reads(l.currency ?? m.currencyKey, `the lottery ${l.name ?? l.key}`), reads(l.ticketCurrency, `the lottery ${l.name ?? l.key}`);
+  for (const c of m.contests) reads(c.currency ?? m.currencyKey, `the contest ${c.name ?? c.key}`);
+  for (const a of m.auctions) reads(a.currency ?? m.currencyKey, `the auction ${a.name ?? a.key}`);
+  for (const s of m.schedules.filter((x) => x.sealed)) reads(s.currency ?? m.currencyKey, `the sealed schedule ${s.name ?? s.key}`);
+  for (const t of named) {
+    const what = `the token ${t.symbol ?? t.key} (“${t.key}”)`;
+    if (t.wsol) {
+      if (t.decimals !== 9) throw new MintMismatch(`The spec gives ${what} ${t.decimals} decimals; its mint ${t.mint} is wrapped SOL, which has 9. Write "decimals": 9.`);
+      continue;
+    }
+    if (typeof chain.account !== 'function') throw new MintMismatch(`This connection cannot read the chain, so the decimals of ${what} at ${t.mint} cannot be checked.`);
+    const account = await chain.account(t.mint);
+    const mint = account ? parseMint(t.mint, account.owner, account.data) : null;
+    if (!mint) throw new MintMismatch(`The spec names ${what} at ${t.mint}, and there is no token mint there.`);
+    if (mint.decimals !== t.decimals) throw new MintMismatch(`The spec gives ${what} ${t.decimals ?? 'no'} decimals; its mint ${t.mint} has ${mint.decimals}, so every amount in it would be ${scale(t.decimals ?? 0, mint.decimals)} what the page shows. Write "decimals": ${mint.decimals}.`);
+    if (mint.program !== t.program) throw new MintMismatch(`The spec says ${what} is a ${t.program} token; its mint ${t.mint} is ${mint.program}. Write "program": "${mint.program}".`);
+    if (once.has(t.key) && mayStartFrozen(account))
+      throw new MintMismatch(`The mint ${t.mint} of ${what} has a default account state that starts new accounts frozen, or that its freeze authority can switch to frozen, so ${once.get(t.key)} would be refused as it opens (the program refuses such a mint wherever a refund or a payout goes into an account opened for it). Use another token there.`);
+  }
+  await checkTreasury({ m, chain });
+}
+
+/** Programs whose own accounts are often pasted where their vault was meant: a multisig's or a DAO's account. */
+const HOLDS_A_VAULT = {
+  SQDS4ep65T869zMMBKyuUq6aD6EgTu8psMjkvj52pCf: 'a Squads multisig’s own account, not its vault',
+  SMPLecH534NA9acpos4G6x7uf3LWbCAwZQE9e8ZekMu: 'a Squads v3 multisig’s own account, not its vault',
+  GovER5Lthms3bLBqWub97yVrMmEogzX7xNjdXpPPCVZw: 'a Realms governance account, not its treasury',
+};
+
+/**
+ * The treasury the spec names ("wallet:<address>"), against the chain: what every
+ * split leaves goes to the treasury's own account of the mint, which only the treasury's key can move. A wallet, a
+ * Squads vault and a Realms treasury are System's accounts (or not there yet); an account another program owns (a
+ * multisig's own account, a token account, an NFT, a program) signs for nothing, so what went there would be stuck.
+ * Throws MintMismatch (what the spec names does not match the chain).
+ */
+export async function checkTreasury({ m, chain }) {
+  const treasury = m.treasuryWallet;
+  if (!treasury || typeof chain.account !== 'function') return;
+  const account = await chain.account(treasury);
+  if (!account || (account.owner === SYSTEM_PROGRAM && !account.executable)) return;
+  const what = HOLDS_A_VAULT[account.owner] ?? (account.executable ? 'a program' : `an account of the program ${account.owner}`);
+  throw new MintMismatch(`The spec’s treasury ${treasury} is ${what}: nobody can sign for what it would be paid, so every split’s rest would be stuck there. Name the wallet that signs (for a Squads multisig, its vault address; for a Realms DAO, its treasury).`);
+}
+
+/** How much an amount written with `said` decimals is, on a mint of `real` decimals, against what it says. */
+const scale = (said, real) => (said > real ? `${10n ** BigInt(said - real)} times` : `1/${10n ** BigInt(real - said)} of`);

package/js/approve/page.html

@@ -0,0 +1,86 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="xsolana-token" content="__TOKEN__">
+<title>Approve going live · loot</title>
+<style>
+  :root { --bg: #f4f5f7; --panel: #ffffff; --ink: #14171f; --muted: #5b6372; --line: #dfe2e8; --accent: #3446d6; --ok: #1d7f4a; --bad: #b42318; --warn: #8a5a00; --mono: ui-monospace, "SFMono-Regular", Menlo, monospace; }
+  @media (prefers-color-scheme: dark) { :root { --bg: #0f1218; --panel: #171b23; --ink: #e8ebf2; --muted: #9aa3b5; --line: #2a303c; --accent: #8394ff; --ok: #4cc47f; --bad: #ff7a6b; --warn: #e8b04a; } }
+  * { box-sizing: border-box; }
+  body { margin: 0; background: var(--bg); color: var(--ink); font: 15px/1.55 system-ui, -apple-system, "Segoe UI", sans-serif; padding: 32px max(16px, env(safe-area-inset-left)); }
+  main { max-width: 720px; margin: 0 auto; display: flex; flex-direction: column; gap: 20px; }
+  h1 { font-size: 1.5rem; margin: 0; }
+  .muted { color: var(--muted); }
+  .panel { background: var(--panel); border: 1px solid var(--line); border-radius: 10px; padding: 18px 20px; }
+  .row { display: flex; flex-wrap: wrap; gap: 10px; align-items: center; }
+  button { font: inherit; padding: 9px 16px; border-radius: 8px; border: 1px solid var(--accent); background: var(--accent); color: #fff; cursor: pointer; }
+  button.ghost { background: transparent; color: var(--accent); }
+  button:disabled { opacity: .5; cursor: default; }
+  button:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
+  ol { margin: 0; padding-left: 22px; display: flex; flex-direction: column; gap: 6px; }
+  li.done { color: var(--muted); text-decoration: line-through; text-decoration-color: var(--ok); }
+  li .who { font-size: .8rem; color: var(--warn); margin-left: 6px; }
+  li .details { margin: 4px 0 2px; padding-left: 18px; font-size: .85rem; overflow-wrap: anywhere; }
+  code, .mono { font-family: var(--mono); font-size: .85em; overflow-wrap: anywhere; }
+  #log { font-family: var(--mono); font-size: .82rem; white-space: pre-wrap; margin: 0; max-height: 220px; overflow: auto; }
+  .ok { color: var(--ok); } .bad { color: var(--bad); }
+  ul.warn { margin: 0; padding-left: 18px; color: var(--warn); font-size: .9rem; }
+  .flush { margin: 0; } .note { margin: 10px 0 0; } .spread { justify-content: space-between; } .gap { margin-top: 12px; }
+  #wallets { margin-top: 10px; }
+</style>
+</head>
+<body>
+<main>
+  <header>
+    <p class="muted mono flush">loot · devnet · runs on your computer only</p>
+    <h1 id="title">Approve going live</h1>
+    <p class="muted" id="sub">Loading…</p>
+  </header>
+
+  <section class="panel">
+    <div class="row">
+      <button id="connect">Connect a wallet</button>
+      <span id="wallet" class="mono muted"></span>
+    </div>
+    <div class="row" id="wallets" hidden></div>
+    <p class="muted note">Set the wallet to <b>devnet</b>. Each approval shows you the transactions before you sign; nothing leaves your wallet without it. Nobody else ever sees your key.</p>
+  </section>
+
+  <section class="panel">
+    <div class="row spread">
+      <b>What going live does</b>
+      <span class="muted" id="cost"></span>
+    </div>
+    <ol id="steps" class="gap"></ol>
+  </section>
+
+  <section class="panel" id="legalbox">
+    <b>Read this first</b>
+    <ul class="gap" id="terms">
+      <li>The loot program has not been independently audited. It and these tools come as is, with no warranty and no guarantee that they are safe: what is sent to the program can be lost. You use them at your own risk.</li>
+      <li>Transactions can't be undone. You are responsible for every one you approve.</li>
+      <li>Making sure your economy is legal everywhere it is offered is up to you. Nothing here is legal or financial advice.</li>
+    </ul>
+    <ul class="warn gap" id="legal" hidden></ul>
+    <p class="muted note">The full text is in DISCLAIMER.md, in the package.</p>
+    <label class="row gap"><input type="checkbox" id="legalok"> I have read this and accept it. Devnet is not real money; real money needs every point above answered first.</label>
+  </section>
+
+  <section class="panel" id="warnbox" hidden>
+    <b>Before you approve</b>
+    <ul class="warn" id="warnings"></ul>
+  </section>
+
+  <section class="panel">
+    <div class="row">
+      <button id="approve" disabled>Approve the next batch</button>
+      <span id="status" class="muted"></span>
+    </div>
+    <pre id="log"></pre>
+  </section>
+</main>
+<script type="module" src="/js/approve/page.js"></script>
+</body>
+</html>

package/js/approve/page.js

@@ -0,0 +1,203 @@
+// The approval page, in the owner's own browser: the app side of the Wallet Standard (wallets such as Phantom,
+// Solflare and Backpack register through two window events), then for each batch the server prepared: show it, have
+// the wallet sign it, hand the signed copies back. The page never sees a key; the wallet signs. With more than one
+// wallet in the browser, the person picks which; "Switch wallet" picks again. The page starts itself with the
+// session's token from its <meta name="xsolana-token"> (the page allows no inline script).
+import { fromBase64, toBase64 } from '/js/chain/bytes.js';
+
+const CHAIN = 'solana:devnet';
+const $ = (id) => document.getElementById(id);
+
+function walletRegistry() {
+  const wallets = new Set();
+  const api = Object.freeze({
+    register: (...ws) => {
+      for (const w of ws) if (w?.features) wallets.add(w);
+      return () => ws.forEach((w) => wallets.delete(w));
+    },
+  });
+  window.addEventListener('wallet-standard:register-wallet', ({ detail }) => {
+    try {
+      detail(api);
+    } catch (e) {
+      console.error(e);
+    }
+  });
+  window.dispatchEvent(Object.assign(new Event('wallet-standard:app-ready'), { detail: api }));
+  return () => [...wallets].filter((w) => (w.chains ?? []).some((c) => String(c).startsWith('solana:')) && w.features['standard:connect'] && w.features['solana:signTransaction']);
+}
+
+export function approvalPage(token) {
+  const list = walletRegistry();
+  let wallet = null;
+  let account = null;
+  // Stops listening to the connected wallet's account changes.
+  let unlisten = null;
+  // While a batch is out for signing or sending, nothing re-enables Approve (a state refresh landing mid-way did).
+  let busy = false;
+  const api = async (path, body) => {
+    const r = await fetch(path, { method: body ? 'POST' : 'GET', headers: { 'x-xsolana-token': token, 'content-type': 'application/json' }, body: body ? JSON.stringify(body) : undefined });
+    const data = await r.json().catch(() => ({}));
+    if (!r.ok) throw new Error(data.error ?? `HTTP ${r.status}`);
+    return data;
+  };
+  const log = (line, cls = '') => {
+    const el = document.createElement('div');
+    el.textContent = line;
+    if (cls) el.className = cls;
+    $('log').prepend(el);
+  };
+
+  // The last state shown: ticking the legal box shows it again, with Approve enabled or not.
+  let last = null;
+  function render(state) {
+    last = state;
+    $('title').textContent = state.done ? `“${state.name}” is live` : `Approve “${state.name}”`;
+    $('sub').textContent = state.done
+      ? `Every step landed on devnet. ${state.file} now holds the project’s addresses: you can close this page.`
+      : `${state.mode === 'change' ? 'A change to a live economy' : state.mode === 'resume' ? 'A setup that was cut short goes on' : 'A new economy'} from ${state.file}, on the shared loot program ${state.program.slice(0, 6)}…${state.project ? `, in the project ${state.project}${state.wallet ? `, made from your wallet ${state.wallet}` : ''}` : ''}`;
+    $('cost').textContent = state.setupSol !== null && state.mode === 'new' ? `about ${state.setupSol} SOL` : '';
+    const steps = $('steps');
+    steps.replaceChildren(
+      ...[...state.landed.map((l) => ({ ...l, done: true })), ...state.steps].map((s) => {
+        const li = document.createElement('li');
+        li.textContent = s.says;
+        if (s.done) li.className = 'done';
+        if (s.signer === 'authority') {
+          const who = document.createElement('span');
+          who.className = 'who';
+          who.textContent = `the authority signs (${state.authority})`;
+          li.append(who);
+        }
+        // Who it pays and which keys it trusts, read back from the transaction itself, addresses in full.
+        if (s.details?.length) {
+          const ul = document.createElement('ul');
+          ul.className = 'details';
+          ul.append(...s.details.map((d) => Object.assign(document.createElement('li'), { textContent: d })));
+          li.append(ul);
+        }
+        return li;
+      }),
+    );
+    const warnings = state.warnings ?? [];
+    $('warnbox').hidden = !warnings.length || state.done;
+    $('warnings').replaceChildren(...warnings.map((w) => Object.assign(document.createElement('li'), { textContent: w })));
+    // The notice (no warranty, at the owner's own risk, legal where it runs) and this economy's legal flags, in a
+    // block of their own whatever the agent said: Approve waits until the owner ticks that they read them.
+    const legal = state.legal ?? [];
+    $('legalbox').hidden = Boolean(state.done);
+    $('legal').hidden = !legal.length;
+    $('legal').replaceChildren(...legal.map((f) => Object.assign(document.createElement('li'), { textContent: f.says })));
+    const unread = !$('legalok').checked;
+    // A live section the chain does not bear out: nothing can be approved.
+    $('approve').disabled = state.done || !account || busy || Boolean(state.refused) || unread;
+    $('status').textContent = state.done ? 'Done.' : state.refused ? 'Nothing can be approved: see above.' : !account ? 'Connect a wallet first.' : unread ? 'Read the notice above and tick that you have.' : `${state.remaining} transaction${state.remaining === 1 ? '' : 's'} to go.`;
+  }
+
+  async function refresh() {
+    try {
+      // Once a wallet is connected, the steps are read back from what that wallet will sign.
+      render(await api(account ? `/api/state?wallet=${encodeURIComponent(account.address)}` : '/api/state'));
+    } catch (e) {
+      log(e.message, 'bad');
+    }
+  }
+
+  /** Connects `w` and makes its first account the one that approves; the account the wallet switches to follows. */
+  async function connectTo(w) {
+    // Never while a batch is out (the picker stays open meanwhile): the wallet asked to sign it hands it back.
+    if (busy) return;
+    $('wallets').hidden = true;
+    try {
+      const r = await w.features['standard:connect'].connect();
+      const next = r?.accounts?.[0] ?? w.accounts?.[0] ?? null;
+      if (!next) throw new Error('The wallet gave no account.');
+      unlisten?.();
+      unlisten = null;
+      wallet = w;
+      account = next;
+      const events = w.features['standard:events'];
+      if (events?.on) {
+        unlisten = events.on('change', ({ accounts }) => {
+          if (!accounts || wallet !== w || busy) return;
+          account = accounts[0] ?? null;
+          showWallet();
+          refresh();
+        });
+      }
+      showWallet();
+      await refresh();
+    } catch (e) {
+      log(e.message, 'bad');
+    }
+  }
+
+  function showWallet() {
+    $('wallet').textContent = account ? `${wallet.name}: ${account.address}` : `${wallet.name}: no account connected`;
+    $('connect').textContent = 'Switch wallet';
+    $('connect').className = 'ghost';
+  }
+
+  $('legalok').addEventListener('change', () => {
+    if (last) render(last);
+  });
+
+  // One wallet is connected at once; with several in the browser, the person picks one from a list.
+  $('connect').addEventListener('click', () => {
+    if (busy) return;
+    const found = list();
+    if (!found.length) {
+      log('No Solana wallet in this browser. Install one (Phantom, Solflare, Backpack), set it to devnet, then reload.', 'bad');
+      return;
+    }
+    if (found.length === 1) {
+      connectTo(found[0]);
+      return;
+    }
+    const box = $('wallets');
+    box.replaceChildren(
+      Object.assign(document.createElement('span'), { className: 'muted', textContent: 'Pick a wallet:' }),
+      ...found.map((w) => {
+        const button = Object.assign(document.createElement('button'), { className: 'ghost', textContent: w === wallet ? `${w.name} (connected)` : w.name });
+        button.addEventListener('click', () => connectTo(w));
+        return button;
+      }),
+    );
+    box.hidden = false;
+  });
+
+  $('approve').addEventListener('click', async () => {
+    if (busy || !account) return;
+    busy = true;
+    $('approve').disabled = true;
+    // The wallet and account this approval is for, read once: the batch is prepared for, signed by and handed back
+    // from the same one, whatever the wallet switches to meanwhile.
+    const signer = account;
+    const signingWallet = wallet;
+    try {
+      const batch = await api('/api/prepare', { wallet: signer.address });
+      const details = (batch.details ?? []).flat();
+      log(`Asking your wallet to approve ${batch.transactions.length} transaction${batch.transactions.length === 1 ? '' : 's'} in the project ${batch.project}: ${batch.says.join(' | ')}${details.length ? `. ${details.join('. ')}` : ''}`);
+      const sign = signingWallet.features['solana:signTransaction'];
+      const inputs = batch.transactions.map((t) => ({ account: signer, transaction: fromBase64(t), chain: CHAIN }));
+      const outputs = await sign.signTransaction(...inputs);
+      const signed = outputs.map((o) => toBase64(o.signedTransaction));
+      $('status').textContent = 'Sending and confirming…';
+      const state = await api('/api/complete', { wallet: signer.address, id: batch.id, transactions: signed });
+      log(`Landed: ${state.signatures.slice(-batch.transactions.length).join(', ')}`, 'ok');
+      busy = false;
+      render(state);
+      if (!state.done) await refresh();
+    } catch (e) {
+      busy = false;
+      log(e.message, 'bad');
+      await refresh();
+    }
+  });
+
+  refresh();
+}
+
+// The page's own start: the session's token is in the page's <meta name="xsolana-token">.
+const token = document.querySelector('meta[name="xsolana-token"]')?.content;
+if (token) approvalPage(token);