A live bar at the top of the launchpad with a TOKENS / TRADES switch. Every buy and sell appears the moment it lands on-chain.

• TOKENS: live tokens with price, 24h change and bonding progress
• TRADES: every buy and sell in real time, big buys highlighted
• Every item opens the token page
• Engine now stores the full trade history

On-chain withdrawal and bridge steps pay gas from a separate JUMP relayer wallet, with a Telegram alert when it runs low.

Every filled order shows its average fill price and fees. Orders and closed positions placed by your Autopilot are tagged AUTOPILOT.

Open positions now show their dollar result and margin used.

A new Autopilot always starts with a fresh trading session.

Closed positions show market type, margin mode and liquidations; order history shows the full count and loads older pages.

Links from bot messages open a market directly; the running agent and its P/L now show there too.

Each trade risks about 1.25% of the balance at its stop. Stops adapt to each market's volatility. No longs in a falling market, no entries after spikes, 4h break after two losses in a row.

• Position size from risk, not a fixed share of the budget
• Volatility-based stops (1h ATR)
• Market regime filter (BTC + breadth)
• Loss brake

Every run shows what it earned: banked vs open P/L, won/lost count, and each closed trade with entry, exit, reason and holding time.

Stop moves to break-even at +1.5%, half the position is banked at +3%, trailing stop from +2%.

Trend rider now needs at least +0.5% in the last hour and +1.5% in 24h in the same direction, skips vertical spikes over 4% in an hour, and skips markets whose bid/ask spread is wider than 0.30%. It also understands budget, daily income and target in the goal text, and auto-rotate now scans every market.

Autopilot is now one tap away: a card on Markets with quick goals, a live status row while an agent is running, and an Autopilot this market button on every market page.

Self-custody trading sessions are now stored encrypted on the server, so a maintenance restart no longer logs out external wallets.

Stopping an Autopilot never books a position it could not see. Positions already closed by the exchange get their real result from position history, and anything that could not be checked is listed as still open.

Exchange-side failures (5xx, timeouts, internal and database errors) no longer pause an Autopilot. It keeps retrying, tells the owner once when the exchange has issues and again when it is back. A real loss of access is confirmed with a fresh login before pausing.

AI agents trade through a delegated key with a hard per-order spending limit. The engine requires a limit price for those orders, so plain market orders from the Autopilot were being refused. Every agent order now goes out as a limit order with immediate-or-cancel and a tight price band around the mark, so it fills like a market order but stays inside the policy.

• One central change covers every strategy: DCA, dip, momentum, trend and closes
• Buy band +0.6%, sell band -1.0% around the mark, rounded to the market tick
• Confirmed live: the Autopilot opened its first positions right after the fix

JUMP now appears on sei.io/ecosystem under Trading → Trading Bot.

The V2 trading router was announced publicly with a dedicated article and launch video, and its SeiScan name tag was moved to the new contract address.

Media uploaded through the news admin was saved inside the backend container, where the public site could not see it, so new covers returned 404. Uploads are now synced to a dedicated folder every 30 seconds and served straight from disk, with the site as fallback. Older articles with missing covers were repaired too.

When the engine cancels an order on its own — liquidation, insufficient margin or a system cancel — the owner gets a Telegram message explaining why.

The regular trading bot gained a search mode, and /start now offers Quick Trade, Search token and a direct JUMP Terminal button.

Buy-with-any-chain now shows routes and quotes before a wallet is connected, sits in the Wallet screen as its own button, and appears as a third action next to Buy and Sell, including the sticky trade bar.

An AI analysis layer for the Pro chart: ten analysis modes that draw levels and setups directly on the chart, with one-tap sharing. It explains what the chart shows; it does not predict prices.

• 10 modes, results drawn on the chart
• Share the annotated chart to Telegram

/analyse <coin> [timeframe] runs the same analysis in Telegram, including in the community group. Every call is stored and checked later, and /trackrecord shows the results publicly.

A dedicated recorder captures trades, cumulative volume delta and open interest per market. The terminal shows a live trade tape, and the chart can plot CVD, OI and funding.

The chart price scale now drags, auto-fits and formats prices the way traders expect from TradingView-style tools.

Wallet actions — deposit, withdraw, transfer, bridge and testnet faucet with its own history — are gathered in one central hub.

A full charting upgrade: intervals, candle types, log and percent scales, overlays (MA, EMA, Bollinger, SAR, VWAP), sub-indicators (volume, MACD, RSI, KDJ, OBV, WR), drawing tools saved per market, position and order lines, and fullscreen.

trade.jump.je now works in a normal browser with the official Log in with Telegram button. The bot verifies Telegram's signature server-side and issues a session in the same signed format as the mini-app, so the same account, balances and alerts work on desktop. Desktop visitors can choose to open the terminal in Telegram or stay in the browser, and the choice can be remembered.

• Official Telegram login widget, signature verified server-side
• Same account as the mini-app, session expires automatically
• Open in Telegram or browser, with remember-my-choice

New users get a short guided introduction the first time they open the terminal.

After an isolated position closes, part of its collateral can stay in the empty margin bucket. JUMP now detects empty buckets with no open orders and moves that collateral back to the main margin account, so Available and MAX show the real balance.

MAX now accounts for leverage, fees and slippage, so a max-size order is not rejected for a few cents of margin.

Before opening an isolated position, the ticket simulates the margin bucket and shows the real requirement.

Positions close through the dedicated close endpoint, only open positions are listed, and each position card has a quick Close button.

If someone opens a referral link before they have a wallet, the code is now kept and attached at their first session instead of being lost.

Market pages show the project's website and social links.

Users can delegate trading to an agent with strict limits: explicit markets, a fixed budget and a per-order cap enforced by the engine. Autopilot runs strategies such as DCA, dip-buying, momentum and trend-riding, with AI picking markets, and reports every action in a live event log. Stopping it closes everything it opened.

• Delegated keys with an engine-enforced spending limit
• Budget caps and expiry on every Autopilot
• Live event log for every action

Network settings are centralised in the bot and the terminal. Moving to mainnet is a configuration change, and the bot refuses to start if a mainnet endpoint is missing. Faucet and testnet labels appear only on testnet.

The wallet connector added Optimism and Avalanche, and explorer links point to SeiScan.

All account endpoints — orders, positions, balances, withdrawals, transfers, agents and more — verify who is calling. Telegram users are checked with Telegram's signed init data; external wallets use a JUMP session token issued after a wallet signature, bound to that address and time-limited.

• Telegram identity: signed init data, user id must match
• External wallets: signature login, address-bound session token
• Enforced server-side; the client only attaches headers

HTTP client logging was reduced so request URLs, which can carry credentials, are no longer written to system logs. The affected credential was rotated and old logs were cleared.

A separate monitoring process checks every minute: all services, the database, the bot API, the terminal and claim sites, the signing engine, disk space, stuck withdrawals or bridges and the relayer's gas balance. Alerts fire after two failed checks, with a recovery message and a daily report.

Users can withdraw to any address from the trading bot or the mini-app. A relayer pays the gas, and every withdrawal is logged.

Move USDC between the spot and margin accounts inside the terminal.

Split a large order into slices executed over time, with progress tracked in the terminal.

Fund from other EVM chains: the route is quoted, bridged into USDC on Sei and can buy the chosen market automatically. Visible as a preview on testnet; switched on fully with mainnet.

Personal deposit addresses are integrated in the terminal and waiting for engine-side activation on testnet.

An in-app notification inbox, price alerts per market, position and liquidation alerts, favourites with a watchlist and a live market ticker.

Referral codes are attached at first registration, and a referrals screen shows your code, link and referred users.

A single activity view lists deposits, withdrawals, transfers and other account movements.

/price <symbol> [15m|1h|4h|1d] returns a chart image with a full stats table — price, volume, change, open interest and funding — in private chats and groups, with interval buttons and a Trade on JUMP link.

Big moves (3%, 5%, 10%, 20% within an hour, escalating without repeats) and whale trades are posted to SEI Radar with a chart snapshot.

A simplified buy/sell screen for quick trades, next to the full order ticket.

Project owners who claimed their token get a portal on claim.jump.je, opened straight from the bot's earnings menu: real creator earnings with a calculator, their projects and links, referrals and settings.

• Earnings, Projects, Referrals and Settings tabs
• Opens from /earnings in the trading bot

Updating a project's social links now requires Telegram's signed init data. Before, the request trusted a user id sent by the client.

Every resting limit order placed through JUMP is tracked. Every 30 seconds new fills are reconciled once: volume is recorded, points are credited exactly once per fill, and the owner gets a Telegram message if they enabled it. Works for bot wallets and external wallets alike.

Take-profit, stop-loss and confirmation messages are based on the actual filled size and price, not the requested ones.

Spot holdings and margin collateral are shown and used separately, so one never inflates the other.

If the trading engine API briefly fails, the positions view keeps the last known state instead of showing an empty account.

Market sells only fill inside the engine's protective price band, so on a thin order book a sell-100% can fill only partly. Before confirming, Smart Sell reads the live order book and shows how much fills now, at what average price and impact, and what would be left. The user then picks Smart (sell what fills now and list the rest as a limit order), Market only or Limit all. Resting orders on that pair show a fill bar and a cancel button.

• Fill, average price and impact predicted from the live book
• Smart / Market / Limit modes, slippage presets
• Read-only planning: nothing is signed until you confirm

docs.jump.je became the documentation hub for the terminal, the trading bot and the platform.

Self-custody users connect their own wallet and sign in with one signature. They get their own account with separate balances, and can switch between the Telegram wallet and the external wallet.

jump.je/stats shows live platform numbers.

The terminal gained a leaderboard, a profile screen and user settings.

Trading volume through JUMP accrues JUMP Points, tracked server-side per user.

Closed perp results come straight from the engine's position history, so they match on every device. Spot results are rebuilt with average-cost accounting. History is split into Closed and Orders with load-more paging.

One-tap spot buys of 100, 500 or 1,000 USDC with confirmation, editable buy and sell presets, and loading states on every action button.

Shared links open the terminal directly on the right market and carry the referral code.

Toasts report what actually happened: amount bought or received, below-minimum, insufficient balance or slippage.

Every position can be shared as a PnL card — to Telegram with a Trade on JUMP button, copied, or saved as an image.

Each market page got a live candlestick chart.

Markets are grouped by category (crypto, stocks, commodities and more) with filters.

A Report bug button sends the issue, with context, straight to the team.

Every Telegram user gets a ready-to-trade wallet by default, with gasless trading and no connect step. Self-custody users can add their own wallet as a second account. A connect prompt appears only when it is really needed.

The terminal shows balance and account state at a glance, with wallet connect and a bottom navigation bar.

Market digests and pump alerts are posted to Telegram from the same market engine as the terminal.

A discovery screen ranks markets by Hot, Gainers, Losers and New, with 1h/24h/7d timeframes, category filters, sortable columns and sparklines.

SEI Radar started watching trading markets as well as new on-chain tokens.

Open positions and orders are listed in the terminal, with close and cancel.

Each Telegram user's wallet signs in to the trading engine from the isolated signing service. Private keys never leave it, and the bot only receives a session.

The first end-to-end orders were placed from the Telegram mini-app, backed by tests for authentication, sessions, order placement, deposits and the faucet.

A Get USDC button funds new testnet accounts in one tap.

The bot gained a terminal menu and a direct button that opens JUMP Terminal — perps and spot on Sei, built on the Monaco engine — as a Telegram mini-app.

Project owners see the tokens they claimed in a dedicated profile tab.

Paste a token address, explorer link or chart link into the bot and it opens the right token card, with market data looked up automatically.

A dedicated test token was deployed to run the full claim flow on-chain, from ownership verification to creator rewards.

Before a swap, the bot quotes the route through the trading router and shows the expected output.

Portfolio maths and the sell flow were refined on top of the new router and the transfer-tax pre-flight.

Deployed a new on-chain trading router that can buy and sell fee-on-transfer ("tax") tokens — a large class of Sei tokens the previous router simply could not sell, reverting on the AMM invariant. The new router routes through fee-supporting swaps and measures real balance deltas, so taxed and normal tokens both trade cleanly in one atomic transaction.

• Fee-on-transfer swaps on buy and sell — taxed tokens now sellable
• Balance-delta measurement instead of assumed output
• Same external interface — a drop-in address swap for the bot

The concentrated-liquidity (V2) sell path previously passed a zero minimum-out, leaving those sells without slippage protection. The new router computes a real floor from the user's requested minimum, accounting for the platform fee, so V2 sells are protected like every other path.

Every trade now emits a unified event carrying side, venue, amounts in and out, fee and timestamp — cleaner to index for analytics and future dashboards.

Before a sell executes, the bot now simulates the real on-chain output and compares it to the theoretical quote to detect a token's transfer tax. Low taxes go through with a small note; higher taxes surface a clear warning with the exact percentage and expected amount, and possible-honeypot levels ask for explicit confirmation. It never blocks a trade — it makes sure you know what you'll receive before you commit.

• Real output measured on-chain, not assumed from a quote
• Exact tax % shown; the difference is labelled as the token's own tax
• Progressive warnings — quiet under 5%, confirmation at honeypot levels

Fee-on-transfer tokens consume far more gas per swap than standard tokens. Buy and sell gas estimation now falls back to a much higher ceiling so these trades stop failing with out-of-gas partway through.

Many Sei tokens use 6 decimals. Token balances, portfolio values and trade history now read each token's real decimals with a resilient, cached lookup instead of assuming 18 — fixing cases where a real balance showed as dust or a holding displayed with the wrong magnitude.

• Per-token decimals read on-chain and cached, never assumed
• Portfolio and history amounts display at the correct scale

Portfolio value and the welcome-screen total now price holdings from a real on-chain sell quote through the trading router, instead of an unreliable external price for thin tokens. Values are computed fresh on a cache miss rather than falling back to a stale figure.

The bot's RPC list was reordered to lead with endpoints that stay healthy under load, and connectivity now uses a real liveness probe rather than a shallow check — reducing spurious "no liquidity" and rate-limit errors during quick, repeated actions.

A wallet rotation had updated the bot's off-chain fee wallet but not the on-chain router's platform wallet, so trade fees were still routed to the retired address. The router's platform wallet was corrected on-chain so all trade fees now land in the current treasury wallet.

• Router platform wallet updated on-chain to the current treasury
• Lesson captured: rotate wallet in both bot config and contract

The retired V1 router carried a verified "JUMP: Trading Router" name tag on SeiScan, approved by the explorer team. With V2 live at a new address, the source is being verified and the same public name tag re-requested for the new contract so every trade continues to show a recognizable, verified label on the explorer.

• V1 router was explorer-verified and name-tagged
• V2 verification + name-tag request in progress for the new address

Opened a pull request to add JUMP to the official Sei ecosystem/awesome list — part of making the project discoverable to Sei developers and users from the ecosystem's own directory.

Backend for a new Project Claim flow: the owner of an existing Sei token can claim it and earn a lifetime creator share on all trades of that token through JUMP. Ownership is verified in layers — the contract's own owner method first, then the deployer via block-explorer and on-chain fallbacks, then manual review — because renounced ownership is the norm on Sei and a single method would reject most legitimate projects.

• Layered verification: owner() → deployer (explorer + on-chain) → manual
• Signature challenge with replay protection
• Built as an off-chain extension — no change to existing contracts

Once a project is verified, a creator share accrues to the owner on every qualifying trade of that token, alongside the existing cashback and referral streams — the trader always pays the same fee, and the split is handled off-chain at trade time.

Added the storage behind Project Claim — claimed-project records with a configurable per-project fee share, creator reward balances, and an anti-replay challenge table — with headroom for a first-month bonus without a future migration.

The terminal gained a live Pulse feed that derives real market signals from Monaco's public trade stream across several markets — whale prints, volume bursts, buy/sell pressure, momentum and range breaks — pushed in as markets move. Signals that require an authenticated session (liquidations, funding) are intentionally left out until that access is live rather than simulated.

• Real signals computed from live Monaco trades WebSocket, multi-asset
• Whale, volume, bullish/bearish pressure, momentum, breakout/breakdown
• Clean data-source boundary — ready to extend when authenticated feeds land

A full-width live price ticker now runs on both the markets home and each market page, streaming last prices for the top pairs with click-to-open navigation.

On wider screens the terminal now lays out as a proper three-column workspace — chart, order book and order ticket side by side, with the Pulse feed below — while phones keep the vertical stack. Same components, responsive layout only.

• Chart · order book · trade visible together on desktop
• Order book and ticket stay in view while scrolling
• Mobile layout unchanged

A thin status bar now anchors the terminal with live status and quick links to docs, socials and the public status page.

Retired an old client-side admin gate from the news view and moved it to a wallet-owner check, with all privileged actions enforced server-side. Real authorization has always lived on the server; this removes stale client code and tightens the surface.

• Admin UI gated by wallet owner, not a client-side value
• Every privileged request verified server-side

News image uploads now get randomized filenames, an extension derived from the validated content type, a single enforced size limit, and a strict image-type allowlist — closing off unsafe filenames and mismatched types.

• Random UUID filenames — no user-controlled path or name
• Extension from validated MIME, one 5 MB limit, image types only

The in-progress launchpad environment is now access-gated at the edge while it's finalized, so unfinished flows aren't publicly reachable before launch.

Reclaimed a large amount of disk from stale build images and added image cleanup to the routine after build series.

A single referral identity now works everywhere. Share one link and earn from a friend's activity whether they arrive through the Telegram bot, the Monaco terminal, or the web platform. Rewards tier at 50% / 30% / 10% of platform fees.

• One code, resolved by Telegram identity in the mini-app and by wallet on the web
• Terminal and web users get their own code automatically
• Earnings panel shows referred counts by source and Monaco rewards in USDC
• Self-referral and unknown codes rejected

The stats page gained a dedicated Monaco Terminal view with separate Spot and Perp breakdowns — revenue, volume, transactions and traders — mirroring the trading-bot analytics. Marked testnet until Monaco client access is live; data populates as trading begins.

• Spot / Perp sub-tabs, each with revenue, volume, trades and traders
• Live Monaco market overview via a server-side proxy (no cross-origin issues)
• Clearly marked testnet, pending Monaco client ID

A one-tap bug report is now available across the terminal, the platform, and the Telegram bot. Reports are captured server-side so issues can be triaged and fixed quickly.

• Floating report button on terminal and platform, /bug command in the bot
• Reports stored server-side with source, page and steps

The Monaco terminal bridge and the standalone bridge now show real chain and coin logos instead of colored placeholders, matching the production bridge for a consistent look.

The standalone terminal bridge was streamlined to what Monaco actually needs: pick a chain, bridge native or USDC. Removed the extra buy mode and token-address entry to reduce friction.

Wired the Telegram WebApp runtime into the terminal so the mini-app correctly recognizes the signed-in user — enabling instant, connect-free referral links inside Telegram.

Resolved a stray animated highlight that swept across article images on mobile in the Legion news view. Desktop was unaffected.

Confirmed the live router contract on SeiScan — verified source, on-chain fee control, and owner — and synced the codebase to the canonical address so all paths point at the same audited contract.

Applied system and kernel security updates and made the full service stack restart automatically after a reboot, reducing the chance of downtime after maintenance.

A dedicated web terminal for Monaco markets — live order book, price chart, and an order ticket for spot and perpetuals — built as its own fast, standalone app. Currently in beta as the Monaco integration is finalized.

• Live order book and price chart streamed over WebSocket
• Order ticket: Buy/Sell and Long/Short with leverage, market and limit
• Collateral entry with balance shortcuts and position summary
• All 53 Monaco markets, spot and perps

Tapping any level in the order book loads that price into the ticket and switches to a limit order, with a clear visual confirmation on tap.

Reworked how rows are keyed so the book stays fully live without dropping fast taps — prices update instantly and every tap registers.

• Rows keyed by price, so live updates no longer rebuild the list
• Fast repeated taps on the same level always register

Fund a trade from another chain: bridge from Arbitrum, Polygon, Base and more into USDC on Sei, with an automatic best-route quote and a step-by-step progress view. Beta — actively being tested and refined.

• Native token or USDC as the source, best-route quote per pair
• Live step tracker through approval and bridge
• Collateral lands ready in the ticket when the bridge completes

Hardened the funding flow end-to-end: corrected the route request that could reject quotes, and simplified execution so the wallet signature reliably surfaces.

A Monaco area inside the bot: browse live spot and perp markets and view a real order book per market, pulling from Monaco's API. Order execution is gated pending exchange access.

• Live markets list — spot and perps
• Per-market public order book
• Trading actions gated until exchange access lands

A dedicated client, models, and config for talking to Monaco, kept separate from the rest of the bot so the integration can grow cleanly.

Radar now routes across multiple SEI RPC providers with automatic failover, so a single provider hitting rate limits no longer stops token detection.

• Latency-weighted routing across providers
• Circuit breaker isolates failing providers, auto-recovers
• Zero-downtime failover verified live under rate-limit pressure

Docs moved to their own service at docs.jump.je with clean URLs, full SEO, and a lightweight standalone build.

• Clean paths — docs.jump.je/bots/sei-radar
• Per-page metadata, sitemap, robots, Open Graph
• Old /docs links 301-redirect to the new home

Rotated the Radar bot token and masked all RPC keys and secrets across logs and backups.

Tapping BUY on a brand-new token from Radar — one deployed on-chain but without a liquidity pool yet — used to dead-end at "Token not found". The bot now reads the token's name, symbol and supply straight from the contract and shows a clear no-liquidity panel, so you can see what the token is and know Radar will alert when trading opens.

• Reads name / symbol / supply directly from the ERC-20 contract
• Works both from the Radar deep-link and manual /buy
• Genuinely missing contracts still report not found

Buys and sells that would fail for lack of gas or funds now stop early with a readable message stating the wallet balance and what is needed, instead of surfacing a raw RPC error. A silent bug where the balance check was skipped entirely was also fixed, so the guard now runs on both buy and sell.

• Pre-check on both buy and sell paths
• Shows exact balance and amount required
• No more raw RPC errors reaching the user

The Radar scanner now runs on a dedicated WebSocket RPC endpoint instead of shared public infrastructure, eliminating the rate-limiting that could cause it to miss newly deployed tokens. Detection is now real-time and reliable.

• Dedicated WebSocket endpoint for live block subscription
• No more dropped blocks under load
• Every new deployment caught and published

The signing engine authentication introduced days earlier was verified end-to-end and a configuration mismatch between services was found: the shared credential sat in a file the engine did not load, so the fail-closed guard was correctly rejecting every request. Corrected so authorized callers pass and everything else is still refused.

• Fail-closed behaviour worked as designed — nothing was exposed
• Credential now loaded by the service that enforces it
• Re-verified: authorized request passes, unauthorized still refused

Every transfer out of a wallet now requires a TOTP code. Trading stays instant — the second factor sits only on the one action that can't be undone.

• Secret encrypted at rest with a dedicated key, separate from the wallet key
• Eight single-use recovery codes
• Withdrawals lock for fifteen minutes after five wrong codes
• One-time prompt when a wallet is first funded with 2FA still off
• Verified end-to-end on mainnet

Backups are encrypted with age before they leave the server and copied to a private bucket in Europe. Verified by real restore — downloaded, decrypted, and confirmed a valid database dump — not just uploaded.

• The decryption key lives only on the server and in an offline copy
• A compromised bucket or storage account cannot read the data
• 30-day rotation; upload failures alert Telegram

The component that holds keys and signs transactions previously trusted any local caller. It now requires an internal credential on every request except health checks, with a constant-time check that fails closed.

• Not reachable from the internet
• Blocked by firewall
• Requires a credential even locally — three independent layers

A fuzz test of the amount fields found four ways bad input slipped through, including a crash on non-text messages and values like infinity passing validation. Fixed with one shared validator across every amount, percentage, and address field.

• 10 input points hardened
• Rejects non-text, infinity, NaN, and unicode-digit lookalikes
• Four unsafe catch-all error handlers removed
• Backed by an automated test so regressions surface immediately

The internal ops terminal grew to hundreds of megabytes under heavy output. Fixed with proper backpressure so memory stays flat regardless of load, rather than restarting it on a timer.

Five application ports that are all reached through the web server were closed to the outside. The firewall now permits only SSH, HTTP, and HTTPS, and explicitly denies the engine port.

Two database instances had been competing for the same port, and which one a service reached depended on boot order. Consolidated to one canonical instance with every connection verified to point at it.

The bot refuses to start if the database reports zero users when it previously held some, and refuses to mint a wallet when the wallet table looks emptied. Both conditions alert immediately.

When a wallet crosses from empty to funded and 2FA is still off, the bot sends a one-time reminder to turn it on, so a funded wallet is never protected only by luck.

The operator panel was moved to a separate, access-controlled domain rather than sharing the public site.

Backups run at 04:00, restore into a scratch database, and compare row counts across seven tables. A backup that fails verification is rejected and reported. A backup that has never been restored is not a backup.

Bridge assets in from other chains — USDC, USDT, ETH, SOL, BNB, ARB — to trade on SEI.

Tokens trade on a bonding curve; when the target is reached, liquidity migrates to DragonSwap automatically.

The admin surface was rebuilt as a separate app on its own domain, isolated from the public site.

A dedicated production frontend replaced the earlier build — the app that serves jump.je today.

News, reports, and admin routes reworked ahead of the security push.

A dense run of frontend fixes through mid-to-late June — the busiest stretch, ahead of the production rebuild.

A Telegram trading bot launched — buy, sell, wallets, and settings driven from chat.

A separate high-performance service took over wallet handling and swap execution.

Backup-verified fix runs across the bot through late May — buy, sell, and settings handlers reworked over multiple sessions.

June concentrated on the trading bot: dozens of backup-verified fixes across handlers, plus contract adjustments on Jun 11.

Bridge UI and routing built out — chain selector, route preview, and progress tracking across chains.

• Modular bridge components
• Iterated heavily through April

Mid-April hardening across the frontend and admin panel — backup-verified fixes over several days.

Signing-engine tweaks and further frontend fixes as the bridge matured.

The project moved from local development onto the live server: frontend and backend went up together. This is where seipad became jump.

The token creation flow came together — creator, deploy button, and the create views. The single busiest build day of the project.

Wallet connection moved to a modern stack; live price charts added.

Full token pages — card, live chart, header, stats, creator earnings, tabbed detail view, and buy/sell trade effects.

WalletProvider and connect modal, reworked repeatedly through February and March until the flow was smooth.

Solidity contracts built and deployed to SEI testnet.

• Audited contract libraries
• create / buy / sell flows
• Deployed and verified on testnet

The original launchpad: token contract, on-chain deployer, launcher bot, and landing page — first working end-to-end flow, all in week one.

The project reorganized and renamed twice in January, narrowing toward a launchpad focus.

A documentation site captured the plan — 57 files written in a single day.

Tooling to detect freshly deployed tokens on-chain, with caching.

An early backend service for automated on-chain action.

Day zero. The original architecture: two bots over a shared core — the seed that grew into jump.

• A radar/data bot
• A trade bot
• Shared config, database, and models

Underway now, completed before the platform handles any funds.

Planned before public launch. Auditor and report linked here on completion.

Planned before public launch. Summary published afterward.