whitepaper

Skill, separated from capital.

every figure on this page is imported from the same constants file the game engine executes — the document cannot disagree with the product.

# abstract

GETFUNDED applies the funded-account model — long established in foreign-exchange prop trading — to Solana memecoins minted through pump.fun. A trader pays a fixed entry fee, receives a simulated 10 SOL stack, and trades live market prices through three consecutive challenges of rising difficulty (+50%, +100%, +200%). Clearing all three pays a fixed cash prize of 15x the entry fee, in USDC, straight to the trader's wallet.

The design goal is a market where skill is separable from capital and from luck-of-the-launch, and where the cost of losing is bounded and known before you start.

# the problem

Memecoin trading punishes the wrong things. Position size dominates skill, so the trader with the most capital wins the most even when their timing is worse. Losses are unbounded, so one bad night removes a participant permanently. And there is no durable record of performance: a screenshot of a winning trade says nothing about the losing ones.

Prop firms solved the structurally identical problem in FX by separating the evaluation from the capital: demonstrate skill on a simulated balance under enforced risk limits, and the firm supplies real money to whoever passes. GETFUNDED keeps that evaluation and points it at the most volatile market on earth.

# mechanism

Every phase restarts the trader at the same balance against a higher target, so the leaderboard compares decisions rather than bankrolls. The full parameter set:

The exposure cap is measured at entry: a position may not be built beyond 33% of equity, but a winner is never forced down when it grows past that share on its own. Risk is constrained where it is taken — in the sizing decision — not by punishing a correct call.

The drawdown floor is checked on every price tick against net liquidation value — cash plus every position marked at the live quote with the exit fee already deducted. There is no equity number on screen that could not actually be realized.

# the fill engine

Trades are simulated against live market prices. No order is routed to a venue and no on-chain swap occurs, so a fill never moves the real market and never competes with the trader's own wallet.

The fee is not revenue — it exists so that overtrading carries the same drag it carries in the real market. A simulator with zero cost per trade rewards churn, which is the opposite of the skill being measured. The 33% exposure cap and the 10-fill minimum close the two remaining exploits: the all-in coin-flip and the one-lucky-entry pass.

# listing floors

A coin is buyable only if it clears every floor at the moment of the fill:

The attack these prevent is straightforward: since fills settle at the quoted price regardless of size, the engine is only fair if the underlying market is expensive to move. A trader who can push a thin pool for a few hundred dollars could multiply a simulated position against a price they created. The floors make that manipulation cost more than the prize is worth.

Provenance is read from pump.fun's own registry rather than from the mint address. Mints created before the vanity-suffix era — MOODENG, ZEREBRO, TROLL and others — carry no pump ending, and a suffix test would silently exclude some of the most liquid tokens on the platform. The suffix is only used as a provenance fallback when the registry is unreachable and a secondary indexer supplies the universe.

# when a token falls under the floor

Eligibility is evaluated continuously, not once. A token you already hold can drop below the market-cap floor while you own it. Exactly three things happen, and nothing else:

The first rule is absolute: no market-cap check, liquidity check or eligibility check is applied on the sell path, in the engine or in the interface. A collapsing token can cost you money, but it can never trap you in a position.

The third rule is what keeps the evaluation honest. The position keeps being priced from the live market independently of the eligible universe, so its losses continue to count against your equity and can breach the drawdown floor and end the run. Holding a delisted token is not a way to freeze a losing position.

A token you hold stays pinned in the token list whatever the filters say, labelled sell only with its real market cap, so a position is never something you have to hunt for. The buy block carries a 10% tolerance band around the floor so a token oscillating at the boundary does not flicker between tradeable and blocked. If it climbs back above the floor, it becomes buyable again on its own.

# accounts & integrity

An account is a Solana wallet. Signing in means signing a nonce-bearing message with that wallet — there is no password, and the address you sign in with is the address any payout is sent to.

For a signed-in wallet the run is executed on the server, not in the browser. Fills are priced from server-side marks, and the exposure cap, drawdown floor, minimum-fill count and challenge expiry are enforced in the engine before anything is written. The browser holds no authority over the outcome: it renders a mirror of a state it cannot modify. Requests without a valid session are rejected outright.

# price infrastructure

The feed is layered, each layer replaceable without touching the game:

• Discovery. The eligible universe is rebuilt every 60 seconds from indexed PumpSwap pools plus trending Solana pools, filtered by the listing floors, deduplicated to the deepest pool per mint.
• Marks. Live prices arrive by polling — a single batched call for the whole universe — at ~3s on the free tier. With a Helius API key configured, pricing switches to Helius DAS getAssetBatch at ~1.5s ticks, and the free source drops back to slow metadata refreshes (market cap, liquidity, volume, logos). The top bar reports which lane is live.
• Candles. OHLCV history loads per pool and timeframe, then the current candle is painted forward in real time from the mark feed between full resyncs every 20 seconds. Clock skew between the client and the data source merges into the last candle rather than dropping ticks.
• Isolation. Every upstream call is proxied and cached server-side, so a thousand open terminals cost the same upstream quota as one.

# the stack

One deliberate constraint: every game rule lives in a single constants file that both the engine and every page import. Change a number once and the terminal, the checkout, the landing page and this document all follow. Nothing here is hand-copied.

# the prize

Clearing all three challenges pays a fixed cash prize in USDC, sent straight to the wallet you signed in with. There is no funded account to manage and no profit share — you win, the firm pays, it is over. Two entry tiers, one gauntlet:

The rules are identical in both tiers — same targets, same floor, same fills minimum. The free roll exists so the gauntlet can be attempted without spending anything; the prize scales with the entry, not the difficulty.

The economics are a prop-firm classic: the prize is 15x the entry, so the pool of entry fees is only solvent if fewer than one attempt in 15 clears all three. The targets ( +50%, +100%, +200% back to back, under the drawdown floor and the exposure cap) are set to make that the case. Most attempts fail, by design.

# payouts

The prize is paid automatically from a dedicated payout wallet — deliberately not the treasury — to the address you signed in with, after a short safety window.

The prize is recorded against the winning run the instant challenge 03 is cleared, and a unique constraint on the run means a replay or a double-submit can never pay it twice. The delay and the ceiling exist so an anomaly can be caught before money moves rather than after.

# the GETFUNDED token

GETFUNDED is the platform token, and unlike most, it has exactly one job:

No governance theater, no gated formats, no claim on prize pools. Holding GETFUNDED does one thing: it makes every attempt cheaper. That keeps the token's value proposition honest — it is a discount coupon with a market price, and demand for it scales exactly with demand for seats.

Entries paid in GETFUNDED are burned by the firm — sent out of circulation, verifiable on-chain. The treasury never re-sells entry tokens into the market: every seat bought with GETFUNDED is supply that permanently disappears. Demand for seats becomes deflation, not sell pressure.

# limits & risks

Stated plainly, because a whitepaper that only lists strengths is marketing:

• Simulated fills are not real fills. A result here demonstrates timing against live prices, not that the same size could have been executed on-chain at the same price.
• Market data is third-party. Prices, pool statistics and eligibility checks depend on external indexers. If they are wrong or unreachable, quotes and floors are affected.
• The universe depends on an unofficial API. Eligibility is read from pump.fun's own listing endpoint, which is not a documented public interface and can change without notice. A secondary indexer takes over when it does, with narrower coverage.
• One wallet is not one person. Nothing today proves a single human controls a single wallet, so the free tier is farmable by someone willing to spread across addresses. It is capped in reward for that reason, and per-identity limits are the obvious next step.
• Payouts depend on an operator. They are automated, but from a wallet this firm controls, on infrastructure this firm runs. Settlement is not trustless and this document does not claim otherwise.
• Floors are a deterrent, not a proof. They raise the cost of manipulating a thin market above the prize on offer; they do not make manipulation impossible.
• Entry fees will be at risk. Once payments go live, a losing run forfeits the fee. Nothing here is investment advice and no return is promised.

# verifying this document

Every number above is rendered from src/lib/rules.ts — the same constants the fill engine, the risk checks and the checkout execute. If the product changes, this page changes in the same commit, or the build fails. Where something is simulated or unimplemented, this document says so in an amber box rather than implying otherwise.