Roadmap

What's been built, what's next on the contract side, what we've chosen not to do.

Done (v4, current mainnet design)

• JellyPadStaker: in-house liquid staker (jpSEI). Validator delegation via Sei staking precompile. Tiered instant-unstake fee (0.5–4%). 21-day slow unstake. Permissionless claim() for validator rewards. Permissionless rebalance() when buffer dips below trigger.
• Dynamic buffer: effectiveTargetBuffer() computed from max(static, supplyRatio, pendingSlowSei, demand × multiplier). All bounded so an attacker can't force pathological over-buffering.
• JellyPadToken: jpSEI-backed curve, configurable graduation, 1% buy fee, 1% sell fee, 1% graduation fee, auto-DEX migration with LP burned to 0xdEaD.
• JellyPadFactory: 50/50 split of protocol fees (operator/buffer), bounded by MAX_OPERATOR_FEE_BPS = 7000. Creation fee 100% to buffer.
• JellyPadRouter: in-flight stake-on-buy, auto-instantUnstake on sell, 1% protocol fee per leg.
• Wei-vs-usei precompile fix.
• Mainnet deployment with end-to-end smoke test (createToken → buy → graduate → LP burn confirmed) plus 10 adversarial tests, all correctly defeated.
• 87 of 91 unit tests passing. The 4 failures are pre-existing soft-fail bugs in deprecated v1 contracts, unblocked from shipping.
• sei CLI wrapper supporting both testnet and mainnet.
• Reference frontend with chart, swap panel, transactions feed, launch flow, public stake page (/stake), and dev-only operator console (/admin).
• Documentation site (this site).

Not yet built

Indexer

The transaction feed and curve chart currently scan the most recent ~12,000 blocks of Buy / Sell / Swap events on every page load (Sei RPC limits us to 2k blocks per eth_getLogs, so we chunk). For a token with hours-or-days of history this is fine. Long-term lookback or sub-second updates would want a dedicated indexer.

Tasks:

• Index TokenCreated from factory. Cache the token registry.
• Index Buy / Sell / GraduatedToDex from each token.
• Index Saphyre Swap events for graduated tokens.
• Compute mcap, holders, volume per token. Store in Postgres.
• Expose /api/* endpoints that read the index instead of eth_getLogs.

Candidates: Subsquid (has Sei support), The Graph (Sei support is limited; would need self-hosted graph-node), or a small custom Postgres + viem ETL.

Live oracle for SEI/USD

Today every token stores a seiUsdPrice set at creation by the factory owner. Used for the graduation-mcap math. A future revision could read from Sei's oracle precompile (0x0000000000000000000000000000000000000091) so the threshold is genuinely USD-pegged.

TradingView Charting Library

The reference frontend uses DexScreener's iframe for graduated-token charts. The licensed TradingView Charting Library is the industry-standard alternative and is supported behind a feature flag in the codebase (/api/udf/* routes already exist; container loads the bundle from public/charting_library/ if present). Awaits TradingView licence approval.

Aggregator routing

The token is a clean ERC-20 with no transfer fee, so 1inch, Squid, Matcha can route into the Saphyre pair like any other V2 pool. We haven't actively pursued listing. Would mostly be a matter of ensuring our pair is discoverable in their routers' factory lists. Bootstrap of a (jpSEI, WSEI) pool may also help here.

Multi-validator routing

The staker currently delegates to one validator. Future work: spread principal across N top-tier validators, with owner-set weights. Reduces slashing concentration. Requires per-validator delegation tracking in the staker.

Auto-rebalance keepers

rebalance() is permissionless but currently no one is calling it. Needs either:

• A keeper bot that monitors buffer ratio and calls when below trigger
• An incentive built into the call (small bounty payable to caller from buffer surplus)

Frontend yield display

The trade page should show "this pool's jpSEI side has appreciated X% since graduation" so holders can see exactly what they've earned. Requires reading the staker rate at graduation time and again now.

Explicitly NOT doing

Token transfer-fee mechanics

A common alternative for capturing post-graduation volume is a fee-on-transfer hook on the token. Aggregator-incompatible, DEX-warning-prone, reputation-hostile. Stays out.

Cross-chain

The protocol depends on three Sei-specific primitives: the staking precompile, our jpSEI staker, and Saphyre's V2 pairs. The design only works because all three live on the same chain. Cross-chain would require reproducing those primitives, which defeats the point. Sei-only.

Run our own DEX

Pump.fun built PumpSwap as a successor to Raydium. We could fork Saphyre and deploy a JellyPad-only DEX that intercepts every swap to call our staking logic. Significant engineering. Splits liquidity. Not worth it until the protocol has serious volume to motivate the move.

Open-source the contracts

Choosing to keep the contract source closed for now. Bytecode is verifiable on-chain, every claim in these docs is checkable against deployed code, but we don't publish the Solidity source.

Open questions

• Aggregator integration: can we get listed on 1inch / Squid for our tokens? Probably yes since we're not using transfer-fee tokens.
• Sell tax for diamond-hand incentive: could we charge a sliding sell fee based on hold duration (5% if sold in less than a day, 0% if held more than 30 days)? Would require per-holder hold-time accounting on transfer.
• Pool boost mechanism: could the factory periodically donate extra TOKEN to the pool to drive price up over time? Effectively a dilution-of-non-holders mechanic. Edge cases around already-staged sells need thought.