Changelog

- TP/SL take a price or an ROI % that scales with leverage, with quick picks; an ROI target becomes the right price for the side at submit - submitOrder's deps missed the TP/SL state, so values entered after the quantity were never sent; also report a rejected TP/SL instead of hiding it - Remember the last timeframe, chart type and indicators across coins

The study's label shapes had no text and auto size, so they rendered as dots; the text overlay only ran when added from the menu. Draw BUY/SELL labels in the study itself and upgrade saved layouts on load.

Profile card (level, account mode and verified-sign-in chips), My Assets with the BTC equivalent and Deposit/Withdraw, For You with live HLP, HYPE staking and top-vault APRs, the recommend-us survey (saved through /feedback/nps), Markets with Favorites/Hot/New/Gainers/Losers/Turnover and spot/perp, My Rewards as tasks, referral code with Affiliate Portal, and feedback. Account sidebar items renamed as on Bybit (Overview, Rewards Hub, Referral Program, Preference Settings). Translated into es/fr/pt/de.

- /deposit: the full deposit flow (Arbitrum USDC, Solana, any crypto, history) as a page with steps and an FAQ; DepositModal can now render inline. - /withdraw: USDC to an Arbitrum address with fee and amount received shown, a 6-digit emailed code to confirm, a success screen and recent withdrawals. - Deposit button in the signed-in top bar; Deposit and Withdraw in the account sidebar, on Assets and on the dashboard. - The signed-in top bar no longer overflows: links that also live in the account sidebar leave the bar below 1280px (Portfolio, Affiliate, Rewards, Academy move into More) and below 1536px (Scripts, Watchlists, Alerts, Orders, Assets).

- #394 The navbar logo now links to / instead of the BTC desk. - #395 Links to chipatrade.com/community in the More menu (new tab), the landing footer, the community feed's sidebar and the ecosystem page. - #396 /trade-portal like Bybit's: an announcements ticker, hero with Hyperliquid's 24h volume and market count, Trade Spot / Derivatives / Demo, a desk picture drawn from BTC's real 24h price, latest listings and API / mobile / web cards. Linked from the Trade menu; in the sitemap; translated into es/fr/pt/de.

Live Hyperliquid yields (HLP, HYPE staking, trader vaults) with honest APRs, including negative ones; HLP deposit and withdraw from the ChipaX perp balance with the risks and four-day lock stated and acknowledged; trader vaults and staking link to Hyperliquid. /vaults, which listed invented vaults and APYs, now redirects here. Earn added to the top nav and sitemap; translated into es/fr/pt/de.

Rewards reads /rewards/me (Hyperliquid all-time volume plus demo volume) instead of recent fills, so it works for demo-only accounts and counts every trade. The API keys panel talks to the new /api-keys through the proxy, the 'withdraw' scope is gone and the key format shown is the real cx_ prefix. The proxy now returns 204/304 without a body: before, every successful DELETE (keys, alerts, watchlists) reached the browser as a 500.

Bybit-partnerships-style hero, three value points, a filterable grid of the live Chipa products (ChipaX, ChipaTrade, ChipaFlow, the AI assistant, Bots Marketplace, ChipaAuth, ChipaDocs, BinaryOptionsToolsV2, AthenaAI, AxiomTrade API, chipax-python, the community) with how each connects to ChipaX, and Discord/GitHub/X calls to build with the team. ItemList JSON-LD; in the sitemap and the More menu; translated into es/fr/pt/de.

Topic chips, level filters, two-column article cards and paging; article pages with canonical /en URL, Open Graph and AnalysisNewsArticle / BreadcrumbList JSON-LD; a learn card and a newsletter box wired to the existing newsletter API. Articles are in the sitemap; Market Pulse is in the More menu. Translated into es/fr/pt/de.

Dark hero, category sidebar with search (plain GET form, crawlable), paged list with pinned items; article pages server-rendered with title, description, canonical /en URL, Open Graph and NewsArticle + BreadcrumbList JSON-LD, a safe Markdown subset and related announcements. Every announcement is in the sitemap; Announcements added to the More menu. Translated into es/fr/pt/de.

Search Console rejected /social/sitemap.xml with 'Missing XML tag: url' while there were no posts. The feed URL now comes first, dated by the newest post.

Bybit-style three-column feed: section menu, composer with #topics and $coin links, Hot/Latest, likes, comments, sharing, topic and author views, and a rail with sign-up and hot topics. Post pages are server-rendered with their own title, description, canonical /en URL, Open Graph article tags and SocialMediaPosting + BreadcrumbList JSON-LD. /social/sitemap.xml lists every published post with its last change and is referenced from robots.txt. Community added to the top nav; translated into es/fr/pt/de.

Every Hyperliquid perp with $50K+ daily volume: hourly funding, annualised APR, open interest and volume, sortable and filterable (longs pay, shorts pay, cash-and-carry), with summary cards and cash-and-carry cards for coins that have a genuine spot leg. Listed as Funding Rates in the More menu.

Bybit's spread trading pairs spot, perpetuals and dated futures. Hyperliquid has no dated futures, so each card pairs a coin's spot market with its perp: both leg prices, spread and basis, hourly funding and its annualised APR, and buttons that open each leg's desk. Legs whose prices disagree by more than 10% are not the same asset and are skipped. Adds funding to market rows.

Account (email, UID and Hyperliquid address with copy, explorer link, sign out), preferences (language, demo/live mode, hide balances, accent colour), browser notifications for price alerts, and clearing saved favourites. Theme colours now persist per browser. Linked from the account sidebar and the user menu; translated into es/fr/pt/de.

The sidebar lived inside the dashboard page, so it vanished as soon as you opened any of its links. It is now a shared AccountSidebar pinned under the navbar, added through a layout to dashboard, assets, portfolio, orders, watchlists, alerts, notifications, rewards and referral, with the page content offset beside it.

Account sidebar, profile header with UID copy and Hyperliquid address, getting-started steps driven by real account state, total equity card with hide/show, Deposit/Transfer/Trade, perp and spot balances, live markets widget (hot, gainers, new) and explore cards. User menu now links Dashboard and Portfolio. Translated into es/fr/pt/de.

Purple hero with followers, trading days, trades, equity, style tag, favourite and Copy; Performance card (ROI, master's PnL, win rate, drawdown, avg PnL per trade, win/lose bar, ratios); Statistics / Trades / Positions / Verification tabs with an Earnings chart (cumulative ROI and profit) and daily Profit bars. Translated into es/fr/pt/de.

Dark hero with platform stats and a promo slider, three shortcut cards, Leaderboard / All Traders / Favorites / Subscribed tabs, leaderboard shelves (balanced, ROI, new talents, most copied, lowest drawdown), Bybit-style trader cards with favourites, and a followers' guide. Copy, my-copy and lead panels are unchanged. Translated into es/fr/pt/de.

Overview cards (sentiment, volume, sectors), Spot/Perpetual tabs, top gainers / newly listed / trending, category chips, sortable paged table with 24h high, low, sparkline and Trade/Details, favourites, live refresh. Translated into es/fr/pt/de and added to the sitemap; Navbar Markets now opens it.

The auth modal now offers an in-app email/password form with sign-in and create-account tabs when the API has a ChipaAuth key configured, keeping the hosted ChipaAuth page for Google and GitHub. Without the key the modal is unchanged. The API proxy forwards the client IP so sign-in rate limits are per person.

WIP checkpoint: routing and infrastructure, before text is wrapped

- Hero: tag, headline, product line, Sign up free / Try the demo, and continue with Google, GitHub or email; a live market panel beside it with the day's trending perp (24h line) and tabs for hot perps, top gainers and trending Solana tokens (stocks, stables and LSTs filtered out) - A row of real numbers from Hyperliquid: markets, max leverage, spot pairs, 24h volume - Product bento: perpetuals, copy trading, trading bots, Solana memecoins, copy Solana wallets - ChipaX's own dark brand and copy; Bybit's layout, not its look-alike assets

- /solana/copy: track any wallet, a PnL-ranked list of tracked wallets, and a live signal inbox (polled every 5 s, browser notification when the tab is in the background) with each token's rug check - /solana/copy/[address]: on-chain stats, open positions, trades linked to Solscan, and follow settings (SOL per buy, follow sells, skip likely rugs) - One-tap copy: a signal opens the token's swap panel pre-filled (buy amount, or the leader's sell share of your holding) for you to sign in your wallet; likely rugs are shown but not suggested - 'Copy wallets' link on the Solana tokens page

- /bots: trend-following bots on BTC, ETH, SOL, HYPE and XRP, each card with a 90-day out-of-sample backtest after fees, the live paper record since launch and its current position - Start a bot in demo (guests too) or live, with allocation, leverage and a risk acknowledgement for live; your bots with stop (keep or close) - How-it-works sheet with the full rules and recent signals; a methodology note naming the strategies that were tested and rejected - Bots in the navbar; the login button no longer wraps

Logged-out visitors can place demo trades: the first order starts a guest session (never on page view, so crawlers don't create any), positions and balance show as usual, and a note invites them to sign up. Signing in hands the guest's demo over to the account.

- / is a real home page: live Hyperliquid market count and prices, what you can trade, how to start, fees and where your money is, footer links - Sign-in no longer opens by itself on trade desks, demo or markets; it is asked for on account-only pages and when you try to act

The desk fills the screen with the panel tabs peeking below; the page scrolls down to the panel at its full height instead of a resizable strip.

Drag the top edge (or double-click / arrow keys) to resize; the height is remembered per browser. Opening the Rug check tab grows the panel so the report is readable without scrolling a 185px strip.

- Rug check tab: chance of a rug and of never doubling, verdict, the signals behind it, Telegram members/online, dev and holder facts, and ChipaAI's written read (loaded when the tab opens) - Swap panel shows the verdict; buying a likely rug needs a deliberate tick - RUG / WEAK badges in the Solana token list - Tokenized stocks, stablecoins and LSTs are shown as out of scope

- /copy: 7D/30D/All tabs, sort by ROI, PnL, win rate, drawdown, copiers or AUM, search, cards with sparkline, win rate, max drawdown and copier AUM - /copy/[id]: ISR trader page with SEO metadata and JSON-LD — performance chart, trading stats, coin mix, live positions, paged trade history with every trade linked to its Hyperliquid transactions, and the copy sheet - On-chain verification: the browser re-reads the trader's Hyperliquid portfolio and fills directly and recomputes ROI, PnL, drawdown, trades and win rate (lib/copyVerify.ts mirrors the API's copy_stats.py) - Trader pages listed in the sitemap

The previous fix routed blocked logos through Next's /_next/image, which works locally but is switched off on Firebase App Hosting (404 for every URL), so those logos still failed in production. /api/token-logo fetches the logo server-side instead: allow-listed hosts only (IPFS re-pointed at Pinata), redirects must stay on the list, image types only (never SVG), 2 MB cap, 10 s timeout. Responses are cached a week in Next's data cache and marked immutable for the CDN. The unused images config is removed from next.config.ts.

Production /api/solana requests hit GeckoTerminal's keyless rate limit (~15% 503s over 30 min), mostly for tokens with nothing cached yet. - token/pool lookup cached 5 min (was 1): the page's live price comes from Jupiter and the routes only need the pool - latest candles cached 60 s (was 30), trades 30 s (was 15); chart and trades panel poll at the same intervals - IPFS logos go straight to the image optimizer via Pinata: browsers are always refused by ipfs.io, so the direct try only added console errors and delay COINGECKO_API_KEY remains the real fix for the rate limit.

Brand-new tokens showed a blank logo: Jupiter's logo for them is usually a raw ipfs.io link, and ipfs.io refuses cross-site embedding (ERR_BLOCKED_BY_RESPONSE) and throttles servers too. - TokenLogo retries a failed direct load through Next's image optimizer, then falls back to the initial. IPFS links are re-pointed at Pinata's gateway first — ipfs.io, dweb.link, w3s.link and nftstorage.link all answered 429 in testing - the optimizer only fetches from an allow-list of token-image hosts (lib/tokenImageHosts.ts, shared with next.config images.remotePatterns), so it is not an open proxy; quality is pinned to 75 as Next 16 requires - the token desk prefers GeckoTerminal's CDN logo, which loads directly

#372 — price/chart data not loading: GeckoTerminal now answers any request carrying a browser Origin header with 429, so the chart's direct calls failed for everyone. Chart candles and trades now come from new routes (/api/solana/[mint]/candles, /trades) that call GeckoTerminal server-side, cached and shared by all visitors (one short 429 retry, last-good fallback). The chart keeps retrying its first load (3/6/12 s) instead of dying on one failure. With COINGECKO_API_KEY set, the same data comes from CoinGecko's on-chain API under that key's limit. #371 — token pages now look like /trade/BTC: pair bar with 24h stats and wallet, chart, recent trades where the order book sits (pools have no book), swap panel, and a Balances / Token info / About panel below. Phones get /trade's chart and trade modes with the same tab bar. Only one of the desktop/phone trees is mounted, so there is one chart and one set of pollers. Balances are fetched once and shared with the swap panel. #373 — 'noindex' on token pages: they are now server-rendered with the token's name, price, liquidity and volume in the title (≤60 chars), description (≤160), H1, BreadcrumbList/WebPage JSON-LD and a generated About summary, and are indexable. Unknown mints are a real 404. Trending Solana tokens are added to the sitemap.

Keyless CoinGecko barely answers App Hosting's shared IPs, so a second retry only added load and ~6 s to cold coin-page renders. One 800 ms retry, then the instance's last good response. Setting COINGECKO_API_KEY (already read by lib/coinInfo.ts) is what lifts the limit.

Production calls CoinGecko keyless from App Hosting's shared IPs, so bursts hit 429 and pages briefly lost their name, description and supply sections. - cgGet retries 429/5xx twice (800 ms, 2 s; honours Retry-After, capped at 3 s) and falls back to the instance's last good response - drop build-time pre-rendering of the top 20 coins, which fired dozens of CoinGecko calls at once; generateStaticParams returns [] so every coin is still ISR (rendered on first visit, cached, revalidated every minute) Next only caches 200 responses and serves stale entries while a refresh fails, so once a coin's profile loads it stays put.

New content, all server-rendered so crawlers see it: - "price today" summary written from live data (unique text, unlike the copied CoinGecko description) - 30D / 90D / 1Y chart switch done with CSS radios, no client JS - price performance (1h–1y) and intraday low/high by period - spot volume, volume/market cap, oracle price, community sentiment - futures & funding: 7-day average funding, OI vs market cap, hourly funding bar chart - SYM↔USD converter tables, contract addresses (real addresses only, major chains first), cleaner categories (ecosystem/index tags last) - FAQ grows to 8–9 entries (1 SYM in USD, 1-year performance, OI) SEO: titles ≤60 and descriptions ≤155 characters with price up front, WebPage JSON-LD with dateModified and sameAs links, visible "Updated" time, top 20 markets pre-rendered via generateStaticParams. No extra CoinGecko calls — new fields ride on the existing cached requests.

Adds an "Any crypto" option to the deposit modal: pick one of ~1,160 coins, see the minimum and the USDC it yields, get a ChangeNOW pay-in address (with QR, and a memo/tag warning for coins that need one), then follow the exchange through confirming → converting → sending until the USDC reaches the user's ChipaX deposit address. - shown only when /account/deposit/any/currencies reports enabled, i.e. once the API has a ChangeNOW partner key - an exchange still waiting for funds is resumed when the modal reopens - apiErrorText() surfaces FastAPI's `detail` instead of the raw JSON body

Sets NEXT_PUBLIC_JUP_REFERRAL_ACCOUNT (Ca2D3sxi…PQZv7) and a 50 bps fee in apphosting.yaml. Verified against live /order quotes: SOL-fee swaps return the referral account and feeBps 50; mints without a referral token account (e.g. USDC) fall back to Jupiter's default fee, which the desk never hits since every swap is against SOL.

New /solana pages trade any Solana token — meme coins and fresh pump.fun launches included — through Jupiter Swap V2, signed by the user's own wallet (Phantom, Solflare, Backpack via the Wallet Standard). ChipaX never holds Solana keys or funds, and every third-party call runs in the browser so Jupiter's own eligibility rules apply to the actual user. - /solana: Trending / Top traded / New launches lists and search (Jupiter Tokens API), risk flags (suspicious, mint/freeze authority, holder concentration, liquidity), organic score, and the connected wallet's holdings - /solana/[mint]: GeckoTerminal candle chart on the existing TradingView library, token stats and audit, and a swap panel (/order + wallet sign + /execute) with price impact, fees and an explicit acknowledgement before buying a flagged token - keyless Jupiter calls share one queue spaced to its 0.5 RPS limit; optional ChipaX referral fee via NEXT_PUBLIC_JUP_REFERRAL_ACCOUNT and NEXT_PUBLIC_JUP_REFERRAL_FEE_BPS - /solana needs no ChipaX login, so the sign-in prompt no longer auto-opens there; "Memecoins" added to the navbar

Unit geofences by IP and refused ChipaX's US-hosted API for every user. lib/unit.ts now asks Unit from the user's browser and verifies the guardian signatures with WebCrypto (2 of 3 P-256 keys) before an address is shown, so Unit's eligibility check applies to the actual user. - SolanaDeposit reads deposit progress from Unit's /operations directly - a region refusal is shown as such and stops the 20s polling - /account/deposit/solana now only supplies the destination and whitelist

- Deposit modal: USDC (Arbitrum) / SOL & SPL tokens (Solana) switch; new SolanaDeposit component with the Unit deposit address, QR code, supported tokens and minimums, and live deposit progress; Solana deposits also listed in the History tab - Spot markets: route and display Unit tokens by symbol (SOL → USOL pair) with a SOL tag in the market picker - MarketContext exposes spotMarket and marketCoin (the HL pair identifier); chart, order book, pair header and order form now read the spot pair's own data instead of the same-named perp - Order form: spot orders use the pair identifier, and prices/sizes follow HL spot precision (lib/spot.ts) — limit prices were rounded to 1 decimal - Fix deposit history always empty (API wraps the list in { deposits }) Requires the matching ChipaX-API change to /hl/spot/markets.

The Arbitrum deposit address is a freshly derived EOA, so Arbiscan shows it bare — a user comparing the modal against the explorer finds nothing that says ChipaX. Show the name tag here instead, and back it with something checkable. The pill carries the label from GET /verify/address/{address}; the disclosure below it exposes the signed statement, the signature, and a link to Arbiscan's signature verifier. Deliberately not a "verified" badge we award ourselves — a checkmark rendered from our own API response proves nothing, so the UI hands over the material to check elsewhere. The proof renders only when the attestation names the address on screen, so a response that arrives after the address changes is dropped rather than shown against the wrong address. Claude-Session: https://claude.ai/code/session_01LPnHrrySuGwcBAQ9b8sgrU

The popup flow was structurally doomed: phones block popups, and ChipaAuth's cross-origin redirect severs window.opener on desktop, so the login completed inside the popup instead of the app. One flow now: redirect to ChipaAuth in the same tab, come back via the callback, which returns to the page login started from.

The bounty tier pills now read as planned amounts under a visible 'Program not yet active' badge. Reward perks that do not exist yet wear a Soon tag, with a note that XP counts now and reached levels are honored when each perk ships — the XP maths were always real, the unlocks were not.

ChipaAuth's cross-origin redirect severs window.opener, so the callback mistook the popup for a full-page redirect, navigated it to the app, and the popup's own AuthContext consumed the pending token — leaving the real window waiting forever. The popup is now recognised by window.name, which survives the redirect, and the auth popup never consumes a pending token. The ?ref= code captured on first touch now rides the onboard call so the backend can attribute the signup, and the affiliate page counts platform signups alongside HL's on-chain referrals.

The tab bar is now the app-wide navigation on phones: fixed to the bottom everywhere, with the trade page keeping its own copy whose Chart/Trade tabs switch modes in place — tapping those from another page navigates over and opens the requested screen (read via an effect, not the state initializer, which was a hydration mismatch that crashed navigation). Portfolio and alerts tables get minimum widths inside their horizontal scrollers so columns stay readable instead of crushing.

The chart screen is now nothing but the chart: no navbar, no account/asset strip, no drawing toolbar — pan and pinch edge to edge. The LIVE/DEMO and asset strip appears only on the order screen, where choosing an account and market is the task at hand. A bottom tab bar — Chart, Trade, Portfolio, Orders, Alerts — carries both the mode switch and the rest of the app, standing in for the hidden top navbar. Modes toggle by CSS rather than unmounting, so the chart never reloads when flipping between them.

One screen is the chart, full width with a single Trade button; the other is the order screen, form beside the live book with the positions tabs below and a Chart button back — the Bitget/Binance pattern, because on a phone you are either reading the market or placing an order, never both. Desktop keeps the three-column terminal untouched; both live and demo trade pages share the layout.

Login failed on mobile because the ChipaAuth popup either gets blocked or opens as a detached tab whose storage the polling modal never sees. Coarse-pointer/small viewports now use a full-page redirect: the callback stores the token and returns to where login started, and AuthContext consumes a pending token on mount. The trade page was three desktop columns crushed into a phone width. Below md it becomes a scrolling stack — chart at readable height, then the order form, then the book — while the desktop layout is untouched. The bug bounty page now says plainly that the paid program is not active yet: the tiers are the intended future rewards, and disclosures are credited, not paid, until it launches.

?ref= and document.referrer are stored on first touch, before any navigation loses them, and ride along on the login event. The deposit modal beacons once per open.

The navbar badge was hardcoded; it now renders only when NEXT_PUBLIC_HL_TESTNET is set. The wallet-reset copy loses its testnet wording, and notes that the old key stays recoverable — true since the vault, and the thing a user staring at that confirm needs to know.

Direct-to-HL calls (price fallback, live-candle WebSocket) each named their own endpoint, one of them testnet — mixing venues with the backend proxy. NEXT_PUBLIC_HL_TESTNET now decides both, defaulting to mainnet to match the production flip.

Where a Chipa product (ChipaEditor first) sends its user to link their ChipaX account. The request is validated against /oauth/client before anything approvable is shown, sign-in reuses the ChipaAuth modal, and approve/deny/failure all exit by redirecting back to the product with either a code or error=access_denied.

The recorder loaded the whole chart and then panned the visible range across it, so every candle after the entry was already on screen: the outcome was visible before the trade played out, which is not a replay. The charting library edition we ship has no bar-replay mode, so panning was the only thing it could offer. The replay is now painted directly onto a canvas from the candle data. That allows a bar to be revealed while it is still forming — walking open to extreme to close — and it lets the price scale ease toward its new bounds rather than snap, so the chart moves continuously rather than one jump per bar. The entry level, the profit region, the exit marker and a running PnL figure are drawn as the trade progresses. It also removes the iframe canvas compositing that made recordings come out blank: the canvas the user watches is the one being recorded, so there is no second rendering path to drift.

The old share modal painted its own canvas, which meant the exported image and the on-screen preview were two implementations that could drift. ShareTradeCard is now the single source of truth for both: it is sized in container query units, so the same component serves the in-app preview, the 1200x675 landscape export and the two portrait sizes. Export rasterises the card through an SVG foreignObject. That cannot fetch subresources, so the referral QR is encoded to a data URI at render time rather than served as a file — which also keeps the code on the card and the link behind the QR from ever disagreeing. The referral code is still a placeholder pending a real referral backend; it lives in one constant so there is a single place to change.

/demo/portfolio was reading the live Hyperliquid account and showing real balances under a demo URL, which is precisely the confusion the demo mode exists to prevent. Orders and assets had the same problem. All three now read the paper account when the path says demo. A shared adapter reshapes it into the payloads these pages were built against, so they render it unchanged and the two modes cannot drift apart visually — practising on a different-looking screen defeats the point. Portfolio shows demo equity, positions and history; orders lists resting demo orders including armed take-profit and stop-loss exits; assets reports the paper balance with an empty token table, since a paper account has no spot wallet to enumerate. Every loader re-runs when the mode changes rather than leaving the other account's rows on screen.

Demo was only the trading desk, so a demo trader who opened Portfolio or Orders was looking at their real account without being told. The mode belongs to the product, not one page. A proxy rewrites /demo/<anything> onto the same route, so every page renders from the same code with the /demo prefix intact in the address bar, and the client reads the mode straight off the path — no stored preference to go stale and no route to duplicate. /demo alone lands on the trading desk. Internal links carry the mode through a href() helper, so browsing from the demo desk to Portfolio stays in demo and leaving it has to be deliberate. The live/demo switch keeps you on the page you were reading: /demo/trade/ETH toggles to /trade/ETH rather than dumping you at a default market. Verified: /demo, /demo/portfolio, /demo/alerts, /demo/watchlists, /demo/marketplace, /demo/changelog and /demo/orders all render, navbar links from a demo page all point back into /demo, and toggling live from /demo/trade/ETH lands on /trade/ETH.

Demo was a stored preference, so which account an order would hit depended on what the last session had chosen and the URL said nothing. It is now a place: /demo/trade/BTC is the demo desk, /trade/BTC is live, and each pins the mode on arrival — a live link opens live even if the browser last remembered demo, which is the direction that matters. The desk is the same components as live trading, because rehearsing on a different screen than the one you will trade on defeats the point; only the account behind it changes. The header toggle navigates between the two routes instead of flipping state in place, and changing market from inside demo stays in demo rather than dropping into live. Verified: /demo/trade/BTC titles as Demo and lights the amber toggle, clicking live lands on /trade/BTC, and opening /trade/ETH with demo stored as the preference still opens live.

The form already collected them for live trading; they now reach the demo engine too, so a demo order behaves the same way as the live one it is meant to rehearse.

A live/demo switch in the pair header routes the order form, positions, history and balance to the paper account. The mode persists across sessions, because a trader who left in demo yesterday should not return to an order form that looks identical but spends real money — while it is on, the toggle and the header edge are amber. Demo positions are reshaped into the live position format so the existing table renders them unchanged, including the liquidation price the engine computes. Balance shows equity rather than deposits, since that is what an account with open positions is actually worth. Switching modes refetches immediately instead of leaving the other account's numbers on screen until the next poll. Spot is refused in demo: the engine models perps, and silently treating a spot order as a perp would teach the wrong thing.

Every file under public/ returned 404 in production — the logo, the svgs and the whole charting_library, so the chart could not load at all. Removing standalone output did not help: Firebase App Hosting deploys the traced file set, and tracing only keeps what the code demonstrably touches. Nothing references public/ from code, so the entire folder was dropped. The giveaway was that exactly one file survived: public/changelog.json, which the changelog page reads with readFileSync — tracing followed that read and kept it, which is why one asset served while its neighbours did not. outputFileTracingIncludes now pins the folder to every route. Verified against the build output: the trace manifests list all 364 public files, including charting_library.standalone.js and chipa-logo.png, where they previously listed only changelog.json.

exchange.chipatrade.com returned 404 for every file in public/ — the logo, the svgs, and the whole charting_library, so the chart could not load at all. The requests fell through to the prerendered 404 page (x-nextjs-prerender: 1) because output: 'standalone' deliberately omits public/ from the build: a standalone build carries the server and nothing else. The Dockerfile copies public/ and .next/static back in afterwards, so the container was fine and nobody noticed. Firebase App Hosting deploys the build as it finds it, and there was nothing to serve. Standalone is now opt-in through BUILD_STANDALONE, which only the Dockerfile sets. Verified both ways: a default build produces no .next/standalone and keeps public/ in place, and BUILD_STANDALONE=1 still produces the standalone tree the image expects.

next.config.ts reads version.json when the server starts and bakes it into an env var, so a running dev server keeps whatever version it booted with — the footer sat at 2.22.30 while the repo had moved on. The badge now reads the version from the changelog file in /public, which is served from disk and rewritten on every commit, falling back to the build-time value if the fetch fails. Verified against a dev server still holding 2.22.30 in its env: the footer shows 2.23.0.

version.json sat at 2.22.30 with nothing to bump it. A pre-commit hook now raises the patch and a pre-push hook raises the minor and resets the patch, so "2.23.4" reads as four commits since the 23rd release. Both are counters seeded from the version the file already held, so the numbering continues instead of restarting at a commit count. The major stays manual. The bump is staged by the pre-commit hook so it travels in the commit it describes. A pre-push hook can't join the push that triggered it — the refs are already fixed — so the minor lands with the next commit and trails the live deploy by one push. /changelog renders commit history from a JSON file written at commit time, since the deployed build runs from a snapshot without git history. Entries are grouped by day and show the reasoning from the commit body, with plumbing commits filtered out; the version badge in the ticker links to it.

The recording chart was rendered at left:-10000 to keep it out of the way, but browsers throttle rendering for off-screen content, so the charting library never painted and every captured frame was empty background. It now records on screen, scaled down to fit the dialog while keeping its full internal resolution, so the user watches the replay as it captures. Frame compositing also used the parent-side iframe offset together with rects measured inside the iframe: two different coordinate spaces, which under a CSS scale would both misplace and shrink every canvas. In-iframe rects are now used on their own. A capture whose frames are entirely background is reported as a failure instead of handing over a black file, and the finished video plays back in the dialog rather than only being downloadable. Verified in the running app: a scaled on-screen chart composites 7 canvases into a non-blank frame and records a 247KB webm.

The order form now asks the API for the real approval state on load and shows a banner when the agent has lapsed or expires within two weeks, with a one-click re-approve when the key is available in the session. Until now the first sign of a lapsed approval was a rejected order.

"Auto chart patterns" in the Chipa Indicators menu scans the last 400 bars and draws what it finds: double tops and bottoms, head and shoulders and its inverse, and ascending, descending and symmetrical triangles — each outlined leg by leg, labelled, and given its measured target as a dotted line where the pattern implies one. Everything is built from pivots — swing highs and lows that stand clear of their neighbours — because each classic pattern is a statement about the shape of consecutive pivots. Detection is deliberately conservative, with a price tolerance and a minimum pullback, since a pattern drawn where none exists is worse than a blank chart. Overlapping matches resolve to the richer pattern, so a head and shoulders isn't also reported as two double tops. Also fixes header buttons racing the header widget: createButton throws if the header hasn't mounted, and chart-ready doesn't imply header-ready. The buttons had been created on the wrong signal all along and had started failing outright — they now wait on headerReady. Verified against live BTC data: six patterns detected and drawn as 6 labels and 22 outline and target segments.

Bars that close on volume or on price movement are a Trading Platform chart type this Charting Library build doesn't have — but the datafeed decides what a bar is, so they're built here instead and handed over as ordinary bars. New resolutions: V10/V50/V100 close a bar once that much base volume has traded, R25/R50/R100/R250 once the bar spans that much price. Both aggregate from one-minute candles, and each bar keeps the open time of the minute it started so the series stays strictly increasing. Live updates rebuild the tail from recent candles on a poll: a bar that closes on its own terms can't be described by the time-based candle socket. These are approximations — one minute is the finest input Hyperliquid offers, so a bar can overshoot its threshold by whatever happened inside that minute. True range bars need tick data. Verified the aggregation against a synthetic series: 100 candles at volume 3 give ten V30 bars each of exactly 30, a one-per-minute drift gives ten R10 bars each spanning at least 10, and bar times increase strictly in both.

Closed trades in Trade history get a replay button. It opens a dedicated chart sized for video, marks the entry and the exit with the trade's PnL, then pans the visible range forward one bar at a time from before the entry to past the exit while recording, and hands back a .webm to download. Configurable: timeframe, playback speed, 720p/1080p/square output, how many bars of context to show either side, and whether to overlay Quantum Flux. The chart lives in an iframe, so each frame is composited by drawing every chart canvas onto one output canvas at its own offset — panes, scales and all — and that canvas is what MediaRecorder captures. Recording uses its own widget instance off-screen, so the chart being traded on is untouched. Hyperliquid reports fills rather than round trips, so a closing fill is paired with the most recent opening fill on the same coin and side to recover the entry price and time. Verified in the running app: 7 chart canvases composite into a non-blank frame, VP9 is selected, and a 40-frame capture produced an 87KB webm.

/marketplace browses published scripts, publishes new ones with named setting fields per indicator, mints and redeems invite codes, and manages your library. Scripts you add appear under a "FROM MARKETPLACE" heading in the chart's Chipa Indicators menu and apply with their saved inputs.

/watchlists manages named symbol groups: create, rename in place, add and remove symbols, delete, with live mid prices beside each symbol and a link through to that market. The alert dialog gains an "Applies to" selector — this symbol only, or any watchlist — so one alert can cover a whole group.

Restoring chart state with widget.load() after the chart was ready left the chart in a state where createShape and createMultipointShape silently returned undefined. Any user who had drawn something would have lost the BUY/SELL signal labels with no error to explain it. The saved state now goes to the widget constructor's saved_data option instead, which skips the post-ready reload; verified that drawings survive a reload and new shapes can still be created afterwards. Volume Profile (VPVR) joins the Chipa Indicators menu as the first "drawing" indicator: volume is bucketed into 24 price rows over the last 300 bars of the chart's interval and drawn as horizontal bars anchored to the latest bar, with the point of control in gold. Each bar's volume is spread across the price band it actually covered rather than dumped at its close. Clicking the entry again clears it. It is drawn with the shape API because study plots are vertical — one value per bar — and a volume profile is the transpose of that. getVisibleRange() reports {0,0} in this library build, so the window comes from the candle feed.

First batch from the TradingView Premium feature list, limited to what this charting library edition and the Hyperliquid feed can actually support. Hyperliquid caps a candle request at roughly 5,000 bars — measured, not documented: asking for 10,000 one-minute bars returns about 5,200. getBars now walks the range backwards in chunks, capped at eight pages (~40k bars) so a wide range can't fan out into unbounded requests. Enables study_on_study (apply an indicator to another indicator's output), custom_resolutions (type any interval instead of picking from the list) and chart_style_hilo, and adds an Export button that downloads the visible chart data with all indicator columns as CSV.

The drawing toolbar was switched off (left_toolbar disabled and the side toolbar hidden), so none of the line tools were reachable. Enabling it brings back the full set: cursors, trend lines, Gann and Fibonacci, geometric shapes, annotations, patterns, prediction and measurement, emoji, ruler, zoom, magnet, drawing mode, lock all, hide all and remove all. Undo/redo comes back to the header with it, since drawing without undo is painful. Drawings only persist with a save/load adapter, so chart state is saved per symbol to localStorage on the library's autosave signal and restored when the chart is ready — BTC's drawings stay off the ETH chart. Verified in the running app: the toolbar renders every group, and a drawn horizontal line survives a full page reload with its id intact.

The chart's only realtime path was a 10s poll of the candle endpoint, so the price on screen could be ten seconds stale and moved in visible steps. subscribeBars now opens a websocket to Hyperliquid and subscribes to the candle channel for the chart's symbol and interval. It also subscribes to allMids and applies mid prices to the live bar between candle frames: the candle channel only emits on trades, which on a quiet market measured three frames a minute against fourteen for mids. The browser connects to Hyperliquid directly rather than through the API — a persistent socket via Cloud Run would hold an instance open and bill for every second a chart is on screen. The socket points at the same environment the bars come from (the backend candle proxy serves testnet: its last close matched the testnet mid, not mainnet's), overridable with NEXT_PUBLIC_HL_WS_URL. Ticks more than 5% from the last known bar are dropped, so a misconfigured URL degrades to the poll instead of drawing a wrong price. The poll stays as a backstop, and reconnects back off from 1s to 30s. Verified in the running app: the chart's legend price moved through 10 distinct values in 50 seconds, updating within 2s of each change.

The bottom-panel tab is too cramped to actually manage alerts, and there was no way to see at a glance which ones are armed. /alerts now lists every alert with its status, condition, trigger mode, channels, fire count and when it last fired, with filters for active and paused, per-row pause/edit/test/delete and multi-select for bulk pause, resume and delete. Alerts that differ only by id are easy to create by accident, so identical settings are flagged as duplicates in the list. Reachable from the navbar and from a "Manage all" link on the chart's alerts tab, which stays for quick access while trading.

Lets the UI be pointed at a local API with CHIPAX_API_BASE so features can be tested before they are deployed. Defaults to the deployed API, unchanged.

A "🔔 Alert" button on the chart toolbar opens a dialog for the current symbol: condition (crossing, above/below, percent move, Quantum Flux signal), timeframe, trigger frequency, optional message and expiry, and per-alert notification channels — desktop, email, Telegram chat id, Discord webhook and a generic webhook URL. An Alerts tab beside Positions lists alerts with pause, edit, delete and a Test button that fires every channel so wiring can be checked without waiting for a real trigger, plus a log of what has already fired and how each channel delivered. Alerts are evaluated server-side, so AlertNotifier just polls /alerts/events for anything newer than this browser has seen and raises a desktop Notification, requesting permission when the desktop channel is first ticked.

Custom studies can't render text inside a shape plot — the API exposes no text or size for shape markers — so the signal markers were an unreadable ~13px glyph. Read the study's plot values back with exportData and draw a white-on-colour "BUY"/"SELL" badge at each signal bar with the chart shape API instead. Labels are cleared and redrawn when the study is re-added or the timeframe changes, since they're pinned to bar times.

The label shapes render, but they are a ~13px glyph and signals are rare (two in a 301-bar window on BTC 1h), so they are easy to miss. Add a bar_colorer plot that recolours the signal candle itself in bright green or red. bg_colorer was tried first and draws nothing in this library version.

Two separate problems kept the buy/sell markers off the chart: - `shape_label_up`/`shape_label_down` were paired with `textColor` and `histogramBase`, which the library's own shape studies never set. Matching the built-in metainfo (plot_0..plot_3 ids, isHidden, _metainfoVersion 52, scriptIdPart) makes the shape plots draw. - The state machine committed its state only when a new bar opened, so when the library replayed history over the same study instance the state never rewound and the trigger flags were lost. State is now a per-bar timeline that rolls back whenever a bar is re-run. Verified against the rendered canvas: the shape plot draws exactly one marker per signal. Uses the label shape rather than the arrow — at roughly three times the pixel footprint it's the most visible option the custom-study API offers, since it exposes no marker size or text.

The shape plots used `shape_label_up`/`shape_label_down` plus `textColor` and `histogramBase`, none of which the library's own shape studies use, and nothing was drawn. Match the built-in shape metainfo exactly: arrow shapes, `isHidden: false`, and no extra style keys.

Ports the "Quantum Flux [Strict Alternating]" Pine v5 script to a TradingView custom study: denoised OHLC, EMA/z-score/RSI confluence and a strict-alternating BUY/SELL state machine with ATR take-profit and stop-loss levels. All lengths and multipliers are exposed as study inputs. Two PineJS constraints shaped the implementation: - Std.ema/Std.stdev keep running state, so the NaN warm-up bars of the denoised series poisoned them permanently. The denoise falls back to the raw price while its SMAs warm up. - Series only expose the history depth Std.* helpers happen to request, so persistent state is kept in instance fields committed per bar rather than in new_var series. This also makes the non-repainting one-bar shift rollback-safe on the live bar. Adds a "Chipa Indicators" dropdown to the chart header that lists our custom studies and adds the selected one to the chart.