<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width,initial-scale=1" />
    <title>TokenForge — Create Token</title>

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Baloo+2:wght@600;800&display=swap" rel="stylesheet">
    <link rel="stylesheet" href="styles.css?v=ct-panels-final" />

    <script>
        // Browser env for web3.js
        window.global = window;
        window.process = { env: {} };
    </script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/buffer/6.0.3/buffer.min.js"></script>
    <script>
        // Expose Buffer if available, minimal shim otherwise
        (function () {
            try {
                if (typeof window.Buffer === 'undefined' && typeof Buffer !== 'undefined') window.Buffer = Buffer;
                if (typeof window.Buffer === 'undefined') {
                    class MiniBuffer extends Uint8Array {
                        static from(input, enc) {
                            if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) return new MiniBuffer(input);
                            if (typeof input === 'string') {
                                if (enc === 'hex') {
                                    const len = input.length / 2;
                                    const out = new MiniBuffer(len);
                                    for (let i = 0; i < len; i++) out[i] = parseInt(input.substr(i * 2, 2), 16);
                                    return out;
                                }
                                return new MiniBuffer(new TextEncoder().encode(input));
                            }
                            return new MiniBuffer(input);
                        }
                        static alloc(n) { return new MiniBuffer(n); }
                    }
                    window.Buffer = MiniBuffer;
                }
            } catch (_) { }
        })();
    </script>

    <script src="https://cdn.jsdelivr.net/npm/@solana/web3.js@1.95.3/lib/index.iife.min.js"></script>

    <style>
        /* ===== Buttons (outline, soft hover) ===== */
        .btn-outline,
        .btn-like-ghost,
        .btn-ghost,
        .btn-primary {
            appearance: none;
            background: transparent;
            color: #e7e2ff;
            border: 1.5px solid #3a2b77;
            border-radius: 12px;
            padding: 12px 16px;
            font-weight: 800;
            cursor: pointer;
            transition: border-color .18s, box-shadow .18s, transform .12s, background-color .18s;
            text-decoration: none;
            display: inline-flex;
            align-items: center;
            justify-content: center;
            gap: 8px;
        }

        .btn-outline:hover,
        .btn-like-ghost:hover,
        .btn-ghost:hover,
        .btn-primary:hover {
            border-color: #7d5fff;
            background-color: rgba(125, 95, 255, .08);
            box-shadow: 0 0 0 2px rgba(125, 95, 255, .12), 0 10px 24px rgba(125, 95, 255, .10);
            transform: translateY(-1px);
        }

        .btn-primary {
            border-color: #7d5fff;
        }

        .btn-primary[aria-disabled="true"],
        .btn-outline[aria-disabled="true"],
        .btn-like-ghost[aria-disabled="true"],
        .btn-ghost[aria-disabled="true"] {
            opacity: .6;
            pointer-events: none;
        }

        /* ===== Panels ===== */
        .panel {
            border: 1px solid var(--border);
            border-radius: 14px;
            padding: 16px;
            background: #0f0b27;
        }

        .panel h2 {
            margin: 0 0 6px;
        }

        .panel .sub {
            color: var(--muted);
            margin-bottom: 10px;
        }

        /* Hover glows per tier */
        .panel-head:hover {
            border-color: #ffffff;
            box-shadow: 0 0 0 2px rgba(255, 255, 255, .18), 0 12px 40px rgba(255, 255, 255, .12), inset 0 0 0 1px rgba(255, 255, 255, .06);
        }

        .panel-silver:hover {
            border-color: #6aa8ff;
            box-shadow: 0 0 0 2px rgba(106, 168, 255, .18), 0 12px 40px rgba(106, 168, 255, .12), inset 0 0 0 1px rgba(255, 255, 255, .05);
        }

        .panel-gold:hover {
            border-color: #7dff5a;
            box-shadow: 0 0 0 2px rgba(125, 255, 90, .18), 0 12px 40px rgba(125, 255, 90, .12), inset 0 0 0 1px rgba(255, 255, 255, .05);
        }

        .panel-diamond:hover {
            border-color: #ffc04d;
            box-shadow: 0 0 0 2px rgba(255, 192, 77, .18), 0 12px 40px rgba(255, 192, 77, .12), inset 0 0 0 1px rgba(255, 255, 255, .05);
        }

        /* Solana gradient text */
        .solana-grad {
            background: linear-gradient(90deg, #14F195, #80ECFF, #9945FF);
            -webkit-background-clip: text;
            background-clip: text;
            color: transparent;
        }

        /* Flow pills */
        .flow-pills {
            display: flex;
            gap: 8px;
            flex-wrap: wrap;
            margin-top: 8px;
        }

        .pill {
            font-weight: 800;
            padding: 8px 12px;
            border-radius: 999px;
            border: 1.5px solid #3a2b77;
            text-decoration: none;
        }

        .pill:hover {
            border-color: #7d5fff;
            background: rgba(125, 95, 255, .08);
            box-shadow: 0 0 0 2px rgba(125, 95, 255, .12);
        }

        .pill-blue {
            border-color: #6aa8ff;
        }

        .pill-green {
            border-color: #7dff5a;
        }

        .pill-orange {
            border-color: #ffc04d;
        }

        /* Mini KPIs */
        .mini-kpis {
            display: grid;
            grid-template-columns: repeat(3, 1fr);
            gap: 12px;
        }

        @media(max-width:980px) {
            .mini-kpis {
                grid-template-columns: 1fr
            }
        }

        .kmini {
            background: #120e27;
            border: 1.5px solid #3a2b77;
            border-radius: 10px;
            padding: 10px;
        }

        .kmini b {
            font-size: 13px;
            color: #e0d6ff;
        }

        .kmini .val {
            font-size: 16px;
            margin-top: 4px;
        }

        /* Preview */
        .preview {
            display: grid;
            grid-template-columns: 80px 1fr;
            gap: 12px;
            align-items: center;
            background: #120e27;
            border: 1px solid #3a2b77;
            border-radius: 12px;
            padding: 12px;
            margin-top: 12px;
        }

        .preview img {
            width: 80px;
            height: 80px;
            object-fit: cover;
            border-radius: 10px;
            border: 1px solid #3a2b77;
            display: none;
        }

        .preview.flash {
            box-shadow: 0 0 0 2px rgba(125, 255, 90, .18);
            transition: box-shadow .4s;
        }

        /* Logs (compact) */
        #outCT {
            margin: 8px auto 0;
            min-height: 100px;
            /* reduced */
            max-height: 180px;
            /* reduced */
            overflow: auto;
            background: var(--code-bg);
            border: 1px dashed var(--dash);
            border-radius: 12px;
            padding: 10px;
            white-space: pre-wrap;
            word-break: break-word;
            font-size: 13px;
            /* smaller */
            text-align: left;
        }

        .ok {
            color: #7dff5a;
        }

        .warn {
            color: #ffd27a;
        }

        .err {
            color: #ff7a7a;
        }

        .btns-tiny {
            display: flex;
            gap: 6px;
            justify-content: flex-end;
            margin-top: 6px;
        }

        .btns-tiny .btn-like-ghost {
            padding: 6px 10px;
            font-size: 12px;
            border-radius: 10px;
        }

        .status-indicator {
            display: inline-block;
            width: 8px;
            height: 8px;
            border-radius: 50%;
            margin-right: 8px
        }

        .status-connected {
            background: var(--ok);
            box-shadow: 0 0 8px var(--ok)
        }

        .status-disconnected {
            background: var(--err)
        }
    </style>

    <link rel="icon" type="image/svg+xml" href="./img/logo-tokenforge.svg">
    <link rel="icon" type="image/png" sizes="32x32" href="./img/favicon-32.png">
    <link rel="apple-touch-icon" sizes="180x180" href="./img/apple-touch-icon.png">
    <link rel="manifest" href="./manifest.webmanifest">
    <meta name="theme-color" content="#000000">
</head>

<body>
    <div class="nav">
        <div class="nav-inner">
            <div class="brand">
                <svg viewBox="0 0 64 64" aria-hidden="true">
                    <defs>
                        <linearGradient id="nav-grad" x1="0" y1="0" x2="1" y2="1">
                            <stop offset="0" stop-color="#8F5BFF" />
                            <stop offset=".6" stop-color="#C07CFF" />
                            <stop offset="1" stop-color="#78FFA0" />
                        </linearGradient>
                    </defs>
                    <circle cx="32" cy="32" r="28" fill="#20164a" stroke="#3a2b77" />
                    <path d="M18 22h28v6H36v14h-8V28H18z" fill="url(#nav-grad)" />
                    <path d="M40 28h6v14h-6z" fill="#78ffa0" />
                </svg>
                TokenForge
            </div>

            <a class="link" href="./index.html">Home</a>
            <a class="link" href="./ready-to-launch.html">Ready to Launch</a>
            <a class="link" href="./create-token.html" aria-current="page">Create Token</a>
            <a class="link" href="./create-liquidity.html">Create Liquidity</a>
            <a class="link" href="./dashboard.html">Dashboard</a>
            <a class="link" href="./referrals.html">Referrals</a>
            <a class="link" href="./swap.html">Swap</a>
            <a class="link" href="./tutorial.html">Tutorial</a>
            <div class="spacer"></div>
        </div>
    </div>

    <div class="wrap">
        <div class="grid">

            <!-- Panel 1 — Header / Network -->
            <section class="col-left">
                <div class="panel panel-head" id="panel-top">
                    <h2 class="title">Create your SPL Token on <span class="solana-grad">Solana</span></h2>
                    <div class="sub">Choose the flow you need below:</div>
                    <div class="flow-pills">
                        <a class="pill pill-blue" href="#panel-silver">Classic</a>
                        <a class="pill pill-green" href="#panel-gold">With Metadata</a>
                        <a class="pill pill-orange" href="#panel-diamond">Premium (Metadata + Revoke)</a>
                    </div>

                    <div class="row2 align-start mt-12">
                        <div>
                            <label class="muted">Connection</label>
                            <button class="btn-outline" type="button" onclick="connectWallet()">Connect Wallet</button>
                            <div class="muted mt-6">Phantom · Solflare · Backpack</div>
                            <div id="whoami" class="hint mt-6"><span
                                    class="status-indicator status-disconnected"></span>Not connected</div>
                        </div>
                        <div>
                            <label class="muted">Network</label>
                            <div class="mini-kpis">
                                <div class="kmini"><b>Fee (est.)</b>
                                    <div id="feeMini" class="val">—</div>
                                </div>
                                <div class="kmini"><b>Slot</b>
                                    <div id="slotMini" class="val">—</div>
                                </div>
                                <div class="kmini"><b>Block</b>
                                    <div id="bhMini" class="val">—</div>
                                </div>
                            </div>
                        </div>
                    </div>
                </div>

                <!-- Panel 2 — Silver Classic -->
                <div class="panel panel-silver" id="panel-silver" style="margin-top:16px">
                    <h2 class="title">Silver Classic (create only)</h2>
                    <div class="sub">Create a token with Name, Symbol, Decimals, Initial Supply. Estimated network fee ~
                        0.0035 SOL.</div>

                    <div class="row2 align-start mt-12">
                        <div><label>Name</label><input id="tkName" type="text" placeholder="e.g. Meme Rocket"
                                maxlength="40" /></div>
                        <div><label>Symbol (≤ 10)</label><input id="tkSymbol" type="text" placeholder="e.g. ROCKET"
                                maxlength="10" /></div>
                    </div>
                    <div class="row2 align-start mt-12">
                        <div><label>Decimals (0–9)</label><input id="tkDec" type="number" step="1" min="0" max="9"
                                value="6" /></div>
                        <div><label>Initial Supply</label><input id="tkSupply" type="number" step="any"
                                placeholder="e.g. 100000000" /></div>
                    </div>
                    <div class="row2 align-start mt-12">
                        <div>
                            <label>Upload image (PNG/JPG)</label>
                            <input id="tkImg" type="file" accept="image/png,image/jpeg" />
                            <div class="hint mt-6">Preview only (metadata can be attached later). PNG/JPG · Max ~1MB ·
                                512×512 recommended.</div>
                        </div>
                        <div>
                            <label class="muted">Preview</label>
                            <div id="pvBox" class="preview">
                                <img id="imgPrev" alt="logo preview" src="" />
                                <div>
                                    <div><b id="pvName">—</b> <span class="muted" id="pvSym"></span></div>
                                    <div class="muted mt-6">Decimals: <span id="pvDec">—</span> · Supply: <span
                                            id="pvSup">—</span></div>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="btns-row mt-12">
                        <button class="btn-primary" onclick="createTokenClassic()"><i
                                class="fas fa-plus-circle"></i>&nbsp;Create Classic</button>
                        <button class="btn-like-ghost" type="button" onclick="updatePreview(true)">Update
                            Preview</button>
                    </div>
                </div>

                <!-- Panel 3 — Gold (metadata) -->
                <div class="panel panel-gold" id="panel-gold" style="margin-top:16px">
                    <h2 class="title">Gold (metadata included)</h2>
                    <div class="sub">Create the token and its <b>Metaplex Metadata</b> in the <b>same transaction</b>.
                    </div>

                    <div class="row2 align-start mt-12">
                        <div><label>Name</label><input id="mName" type="text" placeholder="e.g. Meme Rocket"
                                maxlength="40" /></div>
                        <div><label>Symbol (≤ 10)</label><input id="mSym" type="text" placeholder="e.e.g. ROCKET"
                                maxlength="10" /></div>
                    </div>
                    <div class="row2 align-start mt-12">
                        <div><label>Decimals (0–9)</label><input id="mDec" type="number" step="1" min="0" max="9"
                                value="6" /></div>
                        <div><label>Initial Supply</label><input id="mSupply" type="number" step="any"
                                placeholder="e.g. 100000000" /></div>
                    </div>
                    <div class="row2 align-start mt-12">
                        <div><label>Metadata URI (JSON)</label><input id="mUri" type="url"
                                placeholder="https://.../meta/<MINT>.json" /></div>
                        <div><label>Description (optional)</label><input id="mDesc" type="text" maxlength="200"
                                placeholder="Short description (for your JSON file)" /></div>
                    </div>

                    <div class="btns-row mt-12">
                        <button class="btn-primary" onclick="createTokenWithMetadata()"><i
                                class="fa-solid fa-layer-group"></i>&nbsp;Create with Metadata</button>
                        <button class="btn-like-ghost" onclick="openMetaGuide()">How to host JSON</button>
                    </div>
                </div>

                <!-- Panel 4 — Diamond Premium -->
                <div class="panel panel-diamond" id="panel-diamond" style="margin-top:16px">
                    <h2 class="title">Diamond Premium (Metadata + Revoke)</h2>
                    <div class="sub">Everything in one signature: token, metadata, and <b>revoke mint authority</b>.
                        Premium fee applies.</div>

                    <div class="row2 align-start mt-12">
                        <div><label>Name</label><input id="pName" type="text" placeholder="e.g. Meme Rocket"
                                maxlength="40" /></div>
                        <div><label>Symbol (≤ 10)</label><input id="pSym" type="text" placeholder="e.g. ROCKET"
                                maxlength="10" /></div>
                    </div>
                    <div class="row2 align-start mt-12">
                        <div><label>Decimals (0–9)</label><input id="pDec" type="number" step="1" min="0" max="9"
                                value="6" /></div>
                        <div><label>Initial Supply</label><input id="pSupply" type="number" step="any"
                                placeholder="e.g. 100000000" /></div>
                    </div>
                    <div class="row2 align-start mt-12">
                        <div><label>Metadata URI (JSON)</label><input id="pUri" type="url"
                                placeholder="https://.../meta/<MINT>.json" /></div>
                        <div><label>Premium Fee (SOL)</label><input id="pFee" type="number" step="0.01" min="0"
                                value="0.39" /></div>
                    </div>

                    <div class="btns-row mt-12">
                        <button class="btn-primary" onclick="createPremiumAllInOne()"><i
                                class="fa-solid fa-gem"></i>&nbsp;Create Premium</button>
                        <button class="btn-like-ghost" onclick="openMetaGuide()">How to host JSON</button>
                    </div>
                </div>
            </section>

            <!-- Right column: results & compact logs -->
            <section class="col-right">
                <div id="resCard" class="panel" style="display:none">
                    <h2 class="title">Result</h2>
                    <div class="mono"
                        style="font-size:18px;line-height:1.35;color:var(--ok);word-break:break-all;margin-bottom:10px">
                        Mint: <span id="resMint">—</span>
                        <button class="btn-like-ghost" type="button"
                            style="margin-left:10px;padding:6px 10px;border-radius:10px;border:1.5px solid #3a2b77"
                            onclick="copyText(document.getElementById('resMint').textContent)">Copy</button>
                    </div>
                    <div style="display:flex;flex-direction:column;gap:10px;margin-top:8px">
                        <a id="resExplorer" class="btn-like-ghost" target="_blank" rel="noopener">Open in Explorer</a>
                        <a class="btn-like-ghost" href="./dashboard.html">Open Dashboard</a>
                        <a id="resLiquidity" class="btn-like-ghost" href="./create-liquidity.html">Create Liquidity for
                            this token</a>
                    </div>
                    <div id="resNote" class="hint mt-8">Token created successfully. You can now seed liquidity.</div>
                </div>

                <div class="panel">
                    <h2 class="title" style="text-align:center">Activity / Logs</h2>
                    <div id="outCT" class="mono" role="log" aria-live="polite"></div>
                    <div class="btns-tiny">
                        <button class="btn-like-ghost" type="button" onclick="clearLogs()">Clear</button>
                        <button class="btn-like-ghost" type="button" onclick="copyLogs()">Copy</button>
                    </div>
                </div>
            </section>
        </div>
    </div>

    <!-- Success modal -->
    <div id="successMask" class="modal-mask"></div>
    <div id="successModal" class="modal" role="dialog" aria-modal="true" aria-labelledby="mTitle"
        aria-describedby="mDesc" style="display:none">
        <header>
            <div id="mTitle" class="big">✅ Token created!</div>
            <button class="btn-like-ghost" type="button" onclick="hideSuccess()">Close</button>
        </header>
        <div id="mDesc" class="hint">Your mint address:</div>
        <div class="mint mono" id="mintInModal">—</div>
        <div class="cta">
            <a id="modalLiqBtn" class="btn-primary btn-fat" href="./create-liquidity.html"><i
                    class="fa-solid fa-water"></i>&nbsp; Create Liquidity Now</a>
            <div class="row" style="margin-top:8px;display:flex;gap:8px;flex-wrap:wrap">
                <a id="modalExplorer" class="btn-like-ghost" target="_blank" rel="noopener">Open in Explorer</a>
                <a class="btn-like-ghost" href="./dashboard.html">Open Dashboard</a>
            </div>
        </div>
    </div>

    <script>
        // ====== RPC config ======
        const RPC_CONFIG = {
            helius: { http: "https://mainnet.helius-rpc.com/?api-key=1c0c2800-52c0-44d9-b83c-e40a228eaed4", ws: "wss://mainnet.helius-rpc.com/?api-key=1c0c2800-52c0-44d9-b83c-e40a228eaed4", name: "Helius RPC" },
            getblock1: { http: "https://go.getblock.us/9ef8eabb0cd04a45b1bc08d9e2b0d171", ws: "", name: "GetBlock #1" },
            getblock2: { http: "https://go.getblock.us/d2265ce4b5bc40dda4dc1f8be5d49c19", ws: "", name: "GetBlock #2" },
            chainstack: {
                http: "https://solana-mainnet.core.chainstack.com/3f6a8076c1e0ea42a4c8fb7ef49610d2",
                ws: "wss://solana-mainnet.core.chainstack.com/3f6a8076c1e0ea42a4c8fb7ef49610d2",
                name: "Chainstack",
                httpHeaders: { "Authorization": "Basic " + btoa("fervent-benz:rash-pang-ferret-marina-swerve-word") }
            }
        };

        // ====== DOM helpers + logs (clean boot) ======
        const $ = (id) => document.getElementById(id);
        function appendTo(out, msg, cls) {
            const row = document.createElement('div');
            if (cls) row.className = cls;
            row.textContent = '[' + new Date().toLocaleTimeString() + '] ' + msg;
            out.appendChild(row);
            out.scrollTop = out.scrollHeight;
        }
        function logLine(msg, cls) {
            try { appendTo($('outCT'), msg, cls); } catch (_) { }
            try { console.log(msg); } catch (_) { }
        }
        // Suppress the startup "Invalid or unexpected token" noise
        window.addEventListener('error', e => {
            const m = e?.message || String(e);
            if (/Invalid or unexpected token/i.test(m)) { console.warn('Suppressed startup SyntaxError:', m); return; }
            logLine('JS Error: ' + m, 'err');
        });
        window.addEventListener('unhandledrejection', e => {
            const m = e?.reason?.message || e?.reason || 'Unhandled promise rejection';
            logLine('Promise rejection: ' + m, 'err');
        });

        function copyText(text) { navigator.clipboard?.writeText(String(text || '')).then(() => logLine('Copied', 'ok'), () => logLine('Copy failed', 'err')) }
        function clearLogs() { try { $('outCT').innerHTML = ''; } catch (_) { } }
        function copyLogs() {
            const t = Array.from(($('outCT')?.children || [])).map(x => x.textContent).join('\n');
            copyText((t || '').trim());
        }

        // ====== web3.js ======
        let Connection, PublicKey, Transaction, TransactionInstruction, SystemProgram, Keypair;
        let TOKEN_PROGRAM_LEGACY, ASSOCIATED_TOKEN_PROGRAM_ID, SYSTEM_PROGRAM_ID, MEMO_PROGRAM_ID, SYSVAR_RENT_PUBKEY, METADATA_PROGRAM_ID;

        const PROGRAM_IDS = {
            TOKEN: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
            ATA: 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL',
            SYS: '11111111111111111111111111111111',
            MEMO: 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr',
            RENT: 'SysvarRent111111111111111111111111111111111',
            METADATA: 'metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s'
        };

        function ensureWeb3() {
            if (!window.solanaWeb3) throw new Error('web3.js not loaded');
            if (!PublicKey) {
                ({ Connection, PublicKey, Transaction, TransactionInstruction, SystemProgram, Keypair } = window.solanaWeb3);
                TOKEN_PROGRAM_LEGACY = new PublicKey(PROGRAM_IDS.TOKEN);
                ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey(PROGRAM_IDS.ATA);
                SYSTEM_PROGRAM_ID = new PublicKey(PROGRAM_IDS.SYS);
                MEMO_PROGRAM_ID = new PublicKey(PROGRAM_IDS.MEMO);
                SYSVAR_RENT_PUBKEY = new PublicKey(PROGRAM_IDS.RENT);
                METADATA_PROGRAM_ID = new PublicKey(PROGRAM_IDS.METADATA);
            }
        }

        let conn = null, currentRpc = 'chainstack', slotTimer = null;
        function setupConnection() {
            try {
                ensureWeb3();
                const cfg = RPC_CONFIG[currentRpc];
                conn = new Connection(cfg.http, { commitment: 'confirmed', wsEndpoint: cfg.ws || undefined, httpHeaders: cfg.httpHeaders || undefined });
                logLine(`✅ Connected to ${cfg.name}`, 'ok'); startMiniFeed();
            } catch (e) { logLine(`❌ RPC init failed: ${e?.message || e}`, 'err'); }
        }
        async function estimateTipLamportsViaRPC() {
            try {
                const cfg = RPC_CONFIG[currentRpc];
                const r = await fetch(cfg.http, {
                    method: 'POST', headers: { 'Content-Type': 'application/json', ...(cfg.httpHeaders || {}) },
                    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getRecentPrioritizationFees', params: [{ percentile: 50 }] })
                });
                const j = await r.json();
                const arr = Array.isArray(j.result) ? j.result : [];
                const micro = Number(arr[0]?.prioritizationFee || 0);
                const tip = Math.floor(200000 * micro / 1_000_000);
                const base = 5000;
                return (base + tip) / 1_000_000_000;
            } catch (_) { return null; }
        }
        async function refreshFeedOnce() {
            if (!conn) return;
            try {
                const [slot, bh] = await Promise.all([conn.getSlot('finalized'), conn.getBlockHeight('finalized')]);
                $('slotMini').textContent = String(slot); $('bhMini').textContent = String(bh);
            } catch (_) { }
            try {
                const est = await estimateTipLamportsViaRPC();
                $('feeMini').textContent = (est != null) ? est.toFixed(6) + ' SOL' : '—';
            } catch (_) { $('feeMini').textContent = '—'; }
        }
        function startMiniFeed() { try { if (slotTimer) clearInterval(slotTimer); } catch (_) { } refreshFeedOnce(); slotTimer = setInterval(refreshFeedOnce, 7000); }

        // ====== helpers ======
        const isNonEmpty = s => String(s || '').trim().length > 0;
        function clampInt(n, lo, hi) { n = parseInt(n, 10); if (!isFinite(n)) n = lo; return Math.max(lo, Math.min(hi, n)); }
        function u16LE(n) { const a = new Uint8Array(2); a[0] = n & 0xff; a[1] = (n >> 8) & 0xff; return a; }
        function u64LE(big) { let v = BigInt(big); const a = new Uint8Array(8); for (let i = 0; i < 8; i++) { a[i] = Number(v & 0xffn); v >>= 8n; } return a; }
        function concatU8(...parts) { const len = parts.reduce((s, p) => s + p.length, 0); const out = new Uint8Array(len); let o = 0; for (const p of parts) { out.set(p, o); o += p.length; } return out; }
        function encodeStringBorsh(str, maxBytes) {
            const enc = new TextEncoder().encode(str || ''); const slice = enc.slice(0, maxBytes || enc.length);
            const len = new Uint8Array(4); const L = slice.length;
            len[0] = L & 0xff; len[1] = (L >> 8) & 0xff; len[2] = (L >> 16) & 0xff; len[3] = (L >> 24) & 0xff; return concatU8(len, slice);
        }
        function toUnits(amountStr, decimals) {
            const s = String(amountStr || '').trim(); if (!/^\d+(\.\d+)?$/.test(s)) return 0n;
            const [i, f = ''] = s.split('.'); const frac = (f + '0'.repeat(decimals)).slice(0, decimals);
            const unitsStr = (i || '0') + (decimals ? frac : ''); return BigInt(unitsStr.replace(/^0+/, '') || '0');
        }
        function findATAWithProgram(ownerPk, mintPk, tokenProgramId) {
            ensureWeb3(); const seeds = [ownerPk.toBuffer(), tokenProgramId.toBuffer(), mintPk.toBuffer()];
            const [ata] = PublicKey.findProgramAddressSync(seeds, ASSOCIATED_TOKEN_PROGRAM_ID); return ata;
        }
        function ixCreateATAIdempotent(payer, ownerPk, mintPk, tokenProgramId) {
            ensureWeb3(); const ata = findATAWithProgram(ownerPk, mintPk, tokenProgramId);
            const keys = [
                { pubkey: payer, isSigner: true, isWritable: true },
                { pubkey: ata, isSigner: false, isWritable: true },
                { pubkey: ownerPk, isSigner: false, isWritable: false },
                { pubkey: mintPk, isSigner: false, isWritable: false },
                { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false },
                { pubkey: tokenProgramId, isSigner: false, isWritable: false }
            ];
            return { ata, ix: new TransactionInstruction({ keys, programId: ASSOCIATED_TOKEN_PROGRAM_ID, data: new Uint8Array([1]) }) };
        }
        function buildLiqUrl(mintStr, dec) { const q = new URLSearchParams({ mint: mintStr, decimals: String(dec) }); return './liquidity-guide.html?' + q.toString(); }
        function showSuccess(mintStr, liqUrl) {
            $('mintInModal').textContent = mintStr;
            $('modalLiqBtn').href = liqUrl;
            $('modalExplorer').href = 'https://explorer.solana.com/address/' + mintStr;
            $('successMask').style.display = 'block'; $('successModal').style.display = 'block';
        }
        function hideSuccess() { $('successMask').style.display = 'none'; $('successModal').style.display = 'none'; }
        window.hideSuccess = hideSuccess;

        // ====== Wallet init ======
        window.provider = null; window.owner = null;
        (function initWallet() {
            const who = $('whoami');
            const setWho = () => {
                if (window.owner?.toBase58) {
                    const pk = window.owner.toBase58();
                    who.innerHTML = '<span class="status-indicator status-connected"></span>Connected: ' + pk.slice(0, 4) + '…' + pk.slice(-4);
                    who.className = 'hint ok';
                } else {
                    who.innerHTML = '<span class="status-indicator status-disconnected"></span>Not connected';
                    who.className = 'hint';
                }
            };
            setWho();
            window.connectWallet = async function () {
                try {
                    const w = window; const provs = [];
                    if (w.phantom?.solana) provs.push(w.phantom.solana);
                    if (w.solflare?.isSolflare) provs.push(w.solflare);
                    if (w.backpack?.solana) provs.push(w.backpack.solana);
                    if (w.solana?.isPhantom) provs.push(w.solana);
                    if (Array.isArray(w.solana?.providers)) provs.push(...w.solana.providers);
                    if (!provs.length) throw new Error('No wallet provider found');
                    let ok = false, lastErr = null;
                    for (const p of provs) {
                        try {
                            const res = p.connect ? await p.connect({ onlyIfTrusted: false }) : p.request ? await p.request({ method: 'connect' }) : null;
                            window.provider = p; window.owner = p.publicKey || res?.publicKey;
                            if (!window.owner) throw new Error('No public key from wallet');
                            if (p.on) {
                                try {
                                    p.on('accountChanged', (pk) => { window.owner = pk ? (pk.toBase58 ? pk : new (window.solanaWeb3?.PublicKey || class { })(pk)) : null; setWho(); logLine('ℹ️ Account changed', 'warn'); });
                                    p.on('disconnect', () => { window.owner = null; setWho(); logLine('ℹ️ Wallet disconnected', 'warn'); });
                                } catch (_) { }
                            }
                            setWho(); logLine('✅ Connected: ' + window.owner.toBase58(), 'ok'); ok = true; break;
                        } catch (e) { lastErr = e; }
                    }
                    if (!ok) throw lastErr || new Error('Connect failed');
                } catch (e) { logLine('❌ Connect error: ' + (e?.message || e), 'err'); }
            };
        })();

        // ====== UI preview (Panel 2) ======
        function updatePreview(withFlash = false) {
            const name = String(($('tkName').value || '').trim());
            const sym = String(($('tkSymbol').value || '').trim());
            const dec = clampInt(($('tkDec').value || '6'), 0, 9);
            const sup = String(($('tkSupply').value || '').trim());
            $('pvName').textContent = name || '—';
            $('pvSym').textContent = sym ? `(${sym})` : '';
            $('pvDec').textContent = String(dec);
            $('pvSup').textContent = sup || '—';
            if (withFlash) { const box = $('pvBox'); box.classList.add('flash'); setTimeout(() => box.classList.remove('flash'), 350); }
        }
        ['tkName', 'tkSymbol', 'tkDec', 'tkSupply'].forEach(id => { const el = $(id); if (el) el.addEventListener('input', () => updatePreview(false)); });
        $('tkImg')?.addEventListener('change', (e) => {
            const f = e.target.files?.[0]; const img = $('imgPrev');
            if (!f) { img.src = ''; img.style.display = 'none'; return; }
            const url = URL.createObjectURL(f); img.src = url; img.style.display = 'block'; updatePreview(true);
        });

        // ====== Wallet-first multi-signer flow (Phantom recommendation) ======
        async function signWalletFirstThenMint(tx, mintKeypair, connection) {
            if (!window.provider?.signTransaction) {
                throw new Error('Wallet does not support signTransaction; cannot apply wallet-first multi-signer flow.');
            }

            // 1) Wallet signs first - C'EST LA SEULE FOIS qu'on appelle signTransaction
            const walletSigned = await window.provider.signTransaction(tx);

            // 2) Additional signer(s)
            walletSigned.partialSign(mintKeypair);

            // 3) Send
            const sig = await connection.sendRawTransaction(walletSigned.serialize(), { skipPreflight: false });
            return sig;
        }

        // ====== Generic function for Phantom-compliant signing ======
        async function signTransactionPhantomWay(tx, additionalSigners = []) {
            if (!window.provider?.signTransaction) {
                throw new Error('Wallet does not support signTransaction');
            }

            // 1) Wallet signs first
            const walletSigned = await window.provider.signTransaction(tx);

            // 2) Additional signers sign after
            for (const signer of additionalSigners) {
                walletSigned.partialSign(signer);
            }

            return walletSigned;
        }

        // ====== Metaplex Metadata V3 (CreateMetadataAccountV3) ======
        function findMetadataPDA(mintPk) {
            const seed1 = new TextEncoder().encode('metadata');
            const [pda] = PublicKey.findProgramAddressSync([seed1, METADATA_PROGRAM_ID.toBuffer(), mintPk.toBuffer()], METADATA_PROGRAM_ID);
            return pda;
        }
        function buildCreateMetadataV3Data({ name, symbol, uri, sellerFeeBP = 0, isMutable = true }) {
            const ixDiscriminator = new Uint8Array([33]); // CreateMetadataAccountV3
            const namePart = encodeStringBorsh(name, 32);
            const symPart = encodeStringBorsh(symbol, 10);
            const uriPart = encodeStringBorsh(uri, 200);
            const feePart = u16LE(sellerFeeBP);
            const creatorsNone = new Uint8Array([0]);
            const collectionNone = new Uint8Array([0]);
            const usesNone = new Uint8Array([0]);
            const isMut = new Uint8Array([isMutable ? 1 : 0]);
            const collectionDetailsNone = new Uint8Array([0]);
            return concatU8(ixDiscriminator, namePart, symPart, uriPart, feePart, creatorsNone, collectionNone, usesNone, isMut, collectionDetailsNone);
        }
        function ixCreateMetadataV3({ mintPk, payer, updateAuthority, mintAuthority, name, symbol, uri }) {
            const metadataPDA = findMetadataPDA(mintPk);
            const data = buildCreateMetadataV3Data({ name, symbol, uri, sellerFeeBP: 0, isMutable: true });
            const keys = [
                { pubkey: metadataPDA, isSigner: false, isWritable: true },
                { pubkey: mintPk, isSigner: false, isWritable: false },
                { pubkey: mintAuthority, isSigner: true, isWritable: false },
                { pubkey: payer, isSigner: true, isWritable: false },
                { pubkey: updateAuthority, isSigner: true, isWritable: false },
                { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false },
                { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false }
            ];
            return new TransactionInstruction({ programId: METADATA_PROGRAM_ID, keys, data });
        }

        // ====== Shared result wiring ======
        function setResultAndModal(mintPk, dec) {
            const mintStr = mintPk.toBase58();
            try { localStorage.setItem('tf_last_mint', JSON.stringify({ mint: mintStr, decimals: dec })); } catch (_) { }
            logLine('🎯 Mint: ' + mintStr + ' — Mint authority remains ACTIVE (you can revoke later).', 'ok');
            $('resMint').textContent = mintStr;
            $('resExplorer').href = 'https://explorer.solana.com/address/' + mintStr;
            const liqUrl = buildLiqUrl(mintStr, dec);
            $('resLiquidity').href = liqUrl;
            $('resCard').style.display = 'block';
            showSuccess(mintStr, liqUrl);
        }

        // ====== Panel 2: Classic ======
        async function createTokenClassic() {
            try {
                if (!window.owner) await window.connectWallet();
                ensureWeb3(); if (!window.owner) throw new Error('Connect wallet first');
                if (!conn) setupConnection();

                const name = String(($('tkName').value || '').trim());
                const sym = String(($('tkSymbol').value || '').trim());
                const dec = clampInt(($('tkDec').value || '6'), 0, 9);
                const sup = String(($('tkSupply').value || '').trim());
                if (!isNonEmpty(name)) throw new Error('Name required');
                if (!(sym.length <= 10)) throw new Error('Symbol must be ≤ 10 chars');
                const units = toUnits(sup, dec); if (units <= 0n) throw new Error('Initial supply must be > 0');

                const mintKp = Keypair.generate();
                const ownerPk = window.owner.toBase58 ? window.owner : new PublicKey(window.owner);
                const rent = await conn.getMinimumBalanceForRentExemption(82);

                const ixs = [];
                ixs.push(SystemProgram.createAccount({ fromPubkey: ownerPk, newAccountPubkey: mintKp.publicKey, lamports: rent, space: 82, programId: TOKEN_PROGRAM_LEGACY }));
                const dataInit = new Uint8Array(1 + 1 + 32 + 1); dataInit[0] = 20; dataInit[1] = dec & 0xff; dataInit.set(ownerPk.toBytes(), 2); dataInit[34] = 0;
                ixs.push(new TransactionInstruction({ programId: TOKEN_PROGRAM_LEGACY, keys: [{ pubkey: mintKp.publicKey, isSigner: false, isWritable: true }], data: dataInit }));
                const { ata: creatorATA, ix: createATA } = ixCreateATAIdempotent(ownerPk, ownerPk, mintKp.publicKey, TOKEN_PROGRAM_LEGACY); ixs.push(createATA);
                const dataMintTo = new Uint8Array(1 + 8); dataMintTo[0] = 7; dataMintTo.set(u64LE(units), 1);
                ixs.push(new TransactionInstruction({
                    programId: TOKEN_PROGRAM_LEGACY,
                    keys: [{ pubkey: mintKp.publicKey, isSigner: false, isWritable: true }, { pubkey: creatorATA, isSigner: false, isWritable: true }, { pubkey: ownerPk, isSigner: true, isWritable: false }],
                    data: dataMintTo
                }));

                const tx = new Transaction().add(...ixs);
                tx.feePayer = ownerPk;
                const { blockhash, lastValidBlockHeight } = await conn.getLatestBlockhash('finalized');
                tx.recentBlockhash = blockhash;

                let signature;
                try {
                    logLine('🔏 Wallet-first signing flow…', 'ok');
                    signature = await signWalletFirstThenMint(tx, mintKp, conn);
                } catch (e) {
                    // Si l'utilisateur rejette, on NE RETENTE PAS une autre signature
                    if (e.message.includes('User rejected') || e.message.includes('declined') ||
                        e.message.includes('cancel') || e.message.includes('reject')) {
                        logLine('❌ Transaction rejected by user', 'err');
                        throw e; // On propage l'erreur sans retenter
                    }

                    // Fallback uniquement pour les wallets qui ne supportent pas signTransaction
                    if (!window.provider?.signTransaction && window.provider?.signAndSendTransaction) {
                        logLine('⚠️ Using signAndSendTransaction fallback', 'warn');
                        tx.partialSign(mintKp);
                        const r = await window.provider.signAndSendTransaction(tx, { skipPreflight: false });
                        signature = r.signature || r;
                    } else {
                        throw e; // Pour les autres erreurs, on propage
                    }
                }

                logLine('⏳ Sent: ' + signature, 'ok');
                await conn.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, 'confirmed');
                logLine('✅ Confirmed: https://explorer.solana.com/tx/' + signature, 'ok');

                setResultAndModal(mintKp.publicKey, dec);
            } catch (e) {
                logLine('❌ Create error: ' + (e?.message || e), 'err');
                if (e?.logs) logLine('logs: ' + JSON.stringify(e.logs), 'err');
            }
        }

        // ====== Panel 3: Create + Metadata ======
        async function createTokenWithMetadata() {
            try {
                if (!window.owner) await window.connectWallet();
                ensureWeb3(); if (!window.owner) throw new Error('Connect wallet first');
                if (!conn) setupConnection();

                const name = String(($('mName').value || '').trim());
                const sym = String(($('mSym').value || '').trim());
                const dec = clampInt(($('mDec').value || '6'), 0, 9);
                const sup = String(($('mSupply').value || '').trim());
                let uri = String(($('mUri').value || '').trim());
                if (!isNonEmpty(name)) throw new Error('Name required');
                if (!(sym.length <= 10)) throw new Error('Symbol must be ≤ 10 chars');
                const units = toUnits(sup, dec); if (units <= 0n) throw new Error('Initial supply must be > 0');

                const mintKp = Keypair.generate();
                const ownerPk = window.owner.toBase58 ? window.owner : new PublicKey(window.owner);
                const rent = await conn.getMinimumBalanceForRentExemption(82);

                if (!/^https?:\/\//i.test(uri)) {
                    const mintTmp = mintKp.publicKey.toBase58();
                    uri = `https://tokenforge.live/meta/${mintTmp}.json`;
                }

                const ixs = [];
                ixs.push(SystemProgram.createAccount({ fromPubkey: ownerPk, newAccountPubkey: mintKp.publicKey, lamports: rent, space: 82, programId: TOKEN_PROGRAM_LEGACY }));
                const dataInit = new Uint8Array(1 + 1 + 32 + 1); dataInit[0] = 20; dataInit[1] = dec & 0xff; dataInit.set(ownerPk.toBytes(), 2); dataInit[34] = 0;
                ixs.push(new TransactionInstruction({ programId: TOKEN_PROGRAM_LEGACY, keys: [{ pubkey: mintKp.publicKey, isSigner: false, isWritable: true }], data: dataInit }));
                const { ata: creatorATA, ix: createATA } = ixCreateATAIdempotent(ownerPk, ownerPk, mintKp.publicKey, TOKEN_PROGRAM_LEGACY); ixs.push(createATA);
                const dataMintTo = new Uint8Array(1 + 8); dataMintTo[0] = 7; dataMintTo.set(u64LE(units), 1);
                ixs.push(new TransactionInstruction({
                    programId: TOKEN_PROGRAM_LEGACY,
                    keys: [{ pubkey: mintKp.publicKey, isSigner: false, isWritable: true }, { pubkey: creatorATA, isSigner: false, isWritable: true }, { pubkey: ownerPk, isSigner: true, isWritable: false }],
                    data: dataMintTo
                }));
                ixs.push(ixCreateMetadataV3({ mintPk: mintKp.publicKey, payer: ownerPk, updateAuthority: ownerPk, mintAuthority: ownerPk, name, symbol: sym, uri }));

                const tx = new Transaction().add(...ixs);
                tx.feePayer = ownerPk;
                const { blockhash, lastValidBlockHeight } = await conn.getLatestBlockhash('finalized');
                tx.recentBlockhash = blockhash;

                let signature;
                try {
                    logLine('🔏 Wallet-first signing flow…', 'ok');
                    signature = await signWalletFirstThenMint(tx, mintKp, conn);
                } catch (e) {
                    // Si l'utilisateur rejette, on NE RETENTE PAS une autre signature
                    if (e.message.includes('User rejected') || e.message.includes('declined') ||
                        e.message.includes('cancel') || e.message.includes('reject')) {
                        logLine('❌ Transaction rejected by user', 'err');
                        throw e; // On propage l'erreur sans retenter
                    }

                    // Fallback uniquement pour les wallets qui ne supportent pas signTransaction
                    if (!window.provider?.signTransaction && window.provider?.signAndSendTransaction) {
                        logLine('⚠️ Using signAndSendTransaction fallback', 'warn');
                        tx.partialSign(mintKp);
                        const r = await window.provider.signAndSendTransaction(tx, { skipPreflight: false });
                        signature = r.signature || r;
                    } else {
                        throw e; // Pour les autres erreurs, on propage
                    }
                }

                logLine('⏳ Sent: ' + signature, 'ok');
                await conn.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, 'confirmed');
                logLine('✅ Confirmed: https://explorer.solana.com/tx/' + signature, 'ok');

                setResultAndModal(mintKp.publicKey, dec);
            } catch (e) {
                logLine('❌ Create+Metadata error: ' + (e?.message || e), 'err');
            }
        }

        // ====== Panel 4: Premium (Create + Metadata + Revoke + Fee) ======
        const TREASURY_WALLET = 'CRtjchDP2EoSKsWQv38ZFAAQTZyL4pPNokgq2SGyXM6o';
        const LAMPORTS_PER_SOL = 1_000_000_000;

        async function createPremiumAllInOne() {
            try {
                if (!window.owner) await window.connectWallet();
                ensureWeb3(); if (!window.owner) throw new Error('Connect wallet first');
                if (!conn) setupConnection();

                const name = String(($('pName').value || '').trim());
                const sym = String(($('pSym').value || '').trim());
                const dec = clampInt(($('pDec').value || '6'), 0, 9);
                const sup = String(($('pSupply').value || '').trim());
                let uri = String(($('pUri').value || '').trim());
                const feeSol = Number($('pFee').value || '0.39');

                if (!isNonEmpty(name)) throw new Error('Name required');
                if (!(sym.length <= 10)) throw new Error('Symbol must be ≤ 10 chars');
                const units = toUnits(sup, dec); if (units <= 0n) throw new Error('Initial supply must be > 0');

                const mintKp = Keypair.generate();
                const ownerPk = window.owner.toBase58 ? window.owner : new PublicKey(window.owner);
                const rent = await conn.getMinimumBalanceForRentExemption(82);

                if (!/^https?:\/\//i.test(uri)) {
                    const mintTmp = mintKp.publicKey.toBase58();
                    uri = `https://tokenforge.live/meta/${mintTmp}.json`;
                }

                const treasuryPk = new PublicKey(TREASURY_WALLET);
                const lamports = Math.floor(feeSol * LAMPORTS_PER_SOL);

                const ixs = [];
                ixs.push(SystemProgram.createAccount({ fromPubkey: ownerPk, newAccountPubkey: mintKp.publicKey, lamports: rent, space: 82, programId: TOKEN_PROGRAM_LEGACY }));
                const dataInit = new Uint8Array(1 + 1 + 32 + 1); dataInit[0] = 20; dataInit[1] = dec & 0xff; dataInit.set(ownerPk.toBytes(), 2); dataInit[34] = 0;
                ixs.push(new TransactionInstruction({ programId: TOKEN_PROGRAM_LEGACY, keys: [{ pubkey: mintKp.publicKey, isSigner: false, isWritable: true }], data: dataInit }));
                const { ata: creatorATA, ix: createATA } = ixCreateATAIdempotent(ownerPk, ownerPk, mintKp.publicKey, TOKEN_PROGRAM_LEGACY); ixs.push(createATA);
                const dataMintTo = new Uint8Array(1 + 8); dataMintTo[0] = 7; dataMintTo.set(u64LE(units), 1);
                ixs.push(new TransactionInstruction({
                    programId: TOKEN_PROGRAM_LEGACY,
                    keys: [{ pubkey: mintKp.publicKey, isSigner: false, isWritable: true }, { pubkey: creatorATA, isSigner: false, isWritable: true }, { pubkey: ownerPk, isSigner: true, isWritable: false }],
                    data: dataMintTo
                }));
                ixs.push(ixCreateMetadataV3({ mintPk: mintKp.publicKey, payer: ownerPk, updateAuthority: ownerPk, mintAuthority: ownerPk, name, symbol: sym, uri }));
                ixs.push(SystemProgram.transfer({ fromPubkey: ownerPk, toPubkey: treasuryPk, lamports }));
                const dataRevoke = new Uint8Array([6, 0, 0]); // MintTokens -> None
                ixs.push(new TransactionInstruction({
                    programId: TOKEN_PROGRAM_LEGACY,
                    keys: [{ pubkey: mintKp.publicKey, isSigner: false, isWritable: true }, { pubkey: ownerPk, isSigner: true, isWritable: false }],
                    data: dataRevoke
                }));
                const memoStr = `TokenForge Premium: mint ${mintKp.publicKey.toBase58()} + metadata + revoke + fee ${feeSol} SOL`;
                ixs.push(new TransactionInstruction({ programId: MEMO_PROGRAM_ID, keys: [], data: new TextEncoder().encode(memoStr) }));

                const tx = new Transaction().add(...ixs);
                tx.feePayer = ownerPk;
                const { blockhash, lastValidBlockHeight } = await conn.getLatestBlockhash('finalized');
                tx.recentBlockhash = blockhash;

                logLine(`💳 Premium: charging ${feeSol} SOL to treasury ${TREASURY_WALLET.slice(0, 4)}…${TREASURY_WALLET.slice(-4)}`, 'ok');
                logLine('🔐 Mint + Metadata + Revoke in one signature…', 'ok');

                let signature;
                try {
                    logLine('🔏 Wallet-first signing flow…', 'ok');
                    signature = await signWalletFirstThenMint(tx, mintKp, conn);
                } catch (e) {
                    // Si l'utilisateur rejette, on NE RETENTE PAS une autre signature
                    if (e.message.includes('User rejected') || e.message.includes('declined') ||
                        e.message.includes('cancel') || e.message.includes('reject')) {
                        logLine('❌ Transaction rejected by user', 'err');
                        throw e; // On propage l'erreur sans retenter
                    }

                    // Fallback uniquement pour les wallets qui ne supportent pas signTransaction
                    if (!window.provider?.signTransaction && window.provider?.signAndSendTransaction) {
                        logLine('⚠️ Using signAndSendTransaction fallback', 'warn');
                        tx.partialSign(mintKp);
                        const r = await window.provider.signAndSendTransaction(tx, { skipPreflight: false });
                        signature = r.signature || r;
                    } else {
                        throw e; // Pour les autres erreurs, on propage
                    }
                }

                logLine('⏳ Sent: ' + signature, 'ok');
                await conn.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, 'confirmed');
                logLine('✅ Confirmed: https://explorer.solana.com/tx/' + signature, 'ok');
                logLine('✅ Premium: fee captured • MintAuthority revoked • Metadata created', 'ok');

                setResultAndModal(mintKp.publicKey, dec);
            } catch (e) {
                logLine('❌ Premium flow failed: ' + (e?.message || e), 'err');
            }
        }

        // ====== Small guide action ======
        function openMetaGuide() {
            alert('Host your JSON (Metaplex standard) at a public URL. Fields: name, symbol, description, image, attributes[], properties{}. Example: https://docs.metaplex.com/programs/token-metadata/token-standard#json-structure');
        }

        // ====== Boot ======
        window.addEventListener('load', async () => {
            try { ensureWeb3(); } catch (e) { logLine('❌ web3.js not loaded yet', 'err'); }
            updatePreview(false);
            setupConnection();
            logLine('🔧 Page booted', 'ok');
        });
    </script>

    <!-- footer intentionally removed per request -->
</body>

</html>