Every page, every panel, every idea underneath them — including what we can't tell you and why. If a number on this site ever looks like it came out of nowhere, it's explained in here.
What this is, and the one rule everything else follows from.
If you read one thing: every other screener meets a token the day it lists. We meet it the day it's born, because we read BSC blocks ourselves instead of asking anyone what happened. The rest of this manual is what that buys you.
A BSC intelligence terminal that reads the chain itself.
Most screeners are a view onto somebody else's data. They ask an API what happened and show you the answer. StealthX runs its own indexer against BSC blocks: it sees a pool the moment it opens, a trade the moment it lands, and liquidity the moment it leaves. Everything on the site is downstream of that, and where we do use an outside source, this manual says so.
That distinction isn't marketing. It decides what we can know. A third-party API can only tell you about tokens it has decided to track, in the shape it decided to publish, at the moment it decided to refresh. Reading blocks means the limit is what happened on-chain, not what someone chose to expose.
The rule: when our own on-chain check disagrees with a third party, ours wins. We have caught a third-party check calling a healthy token a honeypot, and calling a token fine while our own simulated sells all reverted. Both directions, same week.
We meet a token when it's born. Everyone else meets it when it lists.
A large share of BSC memecoins start on four.meme, on a bonding curve inside its token manager. The token exists, people are buying it, and no DEX has heard of it. It only reaches PancakeSwap if the curve fills — and most never do. Anything watching PairCreated sees only the survivors, and meets them at the finish line.
We read the token manager directly, so a curve token is visible from its first block: who minted it, how many distinct wallets bought in, what its shell is, how far it is from its target. By the time a token lands on a DEX and every other screener starts its chart at zero, we already have its whole life.
Everything else in the product is a consequence of that head start. The graduation verdict exists because we watched the curve fill. The shell registry exists because we fingerprinted the contract at birth. The factory alarms exist because we were there before there was anything else to judge.
Seven ideas. Learn these and every page reads itself.
What the contract is, regardless of what it's called.
We hash every launch's runtime bytecode, stripping the trailing compiler metadata so two copies of one contract match even when they were compiled separately, on different days, by different people. That hash is the token's shell. Names, symbols and logos are costumes; the shell is the body underneath.
This is the only way to see that two unrelated wallets are shipping the same contract. A deployer board groups by wallet and cannot: a rug operation with two wallets looks like two strangers. Grouped by bytecode, they're one.
Every shell gets a class, decided by how concentrated it is — tokens per wallet, not tokens:
Concentration is the signal, not popularity. Forty wallets holding one copy each and two wallets holding one copy each tell the same story: nobody reshipped anything. Past eight distinct wallets a shell is in open circulation and cannot be anyone's private kit — four.meme's standard token sits at hundreds of copies across nearly as many wallets, and calling that a rug ring would condemn most of the chain. We learned this the hard way: an early Factory Floor labelled that exact shell a “shared rug kit”. Twenty-two wallets, one token each, renounced, no owner levers. It was the launchpad's own contract.
“This shell has been used before” is suggestive. “Its pools are all empty” is damning.
Reuse alone proves little — a busy launchpad ships thousands. So for any shell we check what became of what it shipped: every previous token's pool, priced by the quote side's balance, right now.
A shell whose last several pools are all empty, whose tokens die within hours, is not a gamble on the next one. It's a rerun. That's what turns a note into a verdict, and it's why reuse alone caps a score at caution while reuse plus a graveyard is danger.
The median age at death matters as much as the death rate. A shell whose tokens reliably die at four hours is running a timer, and that timer predicts your exit window better than any chart.
A token's life before any DEX exists for it.
A four.meme token raises into a bonding curve until it hits a target written into its own contract at creation. Graduation happens at that target minus a 2% fee. There are two curve types and we read each token's own target out of the manager, per token:
We never convert between them and never compare one against the other's finish line — a rule written in blood. An early version took the median of all graduation amounts to find “the” target. The sample was bimodal: a pile at 17.64 and a pile at 11,760. The median described no curve that has ever existed, and every progress bar downstream of it was wrong.
Most curves die at zero. Of the curves we track, the overwhelming majority never get past a few percent; graduation is the exception rather than the path.
Who actually filled the curve — the question the DEX can never answer.
When a curve fills, the token lands on PancakeSwap and everyone meets it at once: a fresh chart starting at zero. Two tokens can arrive looking identical and be opposites.
Distinct wallets, not trade count — two wallets can make a hundred trades and a hundred wallets can make one each, and only the second is a market. Nothing on the DEX side can ever tell these apart, because the difference happened before the DEX existed for the token. We can, because we watched it.
Pace is measured against the clock, not between the first and last trade. These curves take everything they will ever take in one burst and then sit. Measure between trades and a token nobody has touched in an hour reports as a rocket — silence has to count.
We don't ask whether you can sell. We try.
Honeypot checks that read a contract's source can be fooled by a contract that behaves differently at runtime — and can't say anything at all about a contract that was never verified. So we simulate real swaps against live reserves on our own node, overriding balances so we can trade tokens we don't hold. What comes back isn't a guess; it's what the chain would do if you pressed the button.
The same technique reads owner powers. Rather than trusting a source file, we scan the runtime bytecode's dispatcher for the function selectors that matter — blacklist, pause, mint, fee and limit setters. Unverified contracts have no hiding place.
Nobody hands us a token list. The market discovers itself.
Every few minutes we sweep the chain's swap traffic with no address filter — every swap in the window, whoever it belongs to — count them by pool, and admit the busiest into the index. A token earns its place by being traded, not by being listed somewhere we subscribe to.
Pools quoted on both sides (WBNB/USDT and friends) are dropped. They are the busiest pools on the chain and they tell you nothing about any token, so they would win the sweep every time and crowd out everything worth seeing.
Discovery never runs at the expense of keeping up. The sweep is gated on how far behind the head we are and stands down when the indexer is lagging — a rule that exists because a sweep once ran inside the block loop and put the indexer seven thousand blocks behind the chain.
Momentum, adjusted for the fact that momentum is trivially faked.
Trending scores growth over 24 hours across four axes — volume, trade count, distinct traders and liquidity — then weights the result by absolute size. The weighting is the whole point: growth alone is a percentage, and a token that went from nothing to almost nothing has spectacular percentages. Without a size term the board fills with dust.
Distinct traders carries more weight than trade count, for the reason it always does: trade count is what a bot produces for free, and distinct wallets cost money to fake.
What each one shows, where the data comes from, and how to read it.
The market as our index sees it.
The dashboard is the only page that describes the tool rather than a token. When the numbers along the top move, that's the indexer's coverage changing — new pools admitted by discovery, new deployers seen, new shells fingerprinted.
One address, everything we know. Documented panel by panel in the next chapter.
Paste an address or arrive from any link. Nine panels, each a different way of asking whether this token is what it says it is; the next chapter takes them one at a time.
If the outside world has never heard of the token — because it's dead, rugged, or still pre-DEX — the page doesn't give up. Price is gone, but the chain still tells us who shipped it, what it can do, and what its shell has done elsewhere. That's exactly when you want it most, and exactly when every other screener shows you a 404.
The whole index, live.
An alarm at birth is the earliest warning the product can produce. It says: this contract is byte-identical to a shell whose pools are already empty — and it says it before there is anything else about the token to look at.
Which shells are in circulation, and who ships them.
The Deployer Board groups by wallet; this groups by bytecode. That's the only way to see two unrelated wallets running the same shell, and it's the page that exists purely because of the fingerprint.
Tokens that exist, and don't exist to any DEX.
Read straight from the token manager's own events. When one of these graduates it becomes a PancakeSwap listing that everyone else is meeting for the first time — and we hand you its entire history in the same moment.
Safe picks, with our registry holding a veto.
That per-token check reads each token in isolation — which is exactly the blind spot a template rug is built for. A shell can pass every one of those checks and still be the eighth copy of one a wallet has drained seven times, because nothing about the eighth copy is different. Nothing about it needs to be.
Every wallet we've caught deploying a pair, ranked by abandonment.
Two entries in the sidebar aren't part of the product. Launch (StealthBundler) is unfinished. Organic Engine and its anti-detection machinery are disabled and stay that way — the code exists; the feature does not.
Nine reads on one address. This is where the whole product lands.
One letter grade, and the reasons under it.
Fuses everything below into a grade, and shows you every flag that moved it. It is not a black box: each red and green line is a claim you can go check on the panel it came from.
Precedence matters more than arithmetic here. Anything we established on our own node outranks a third party, in this order:
We buy, then we try to sell. On our node, with real reserves.
A real swap, simulated against live state. If the sell reverts, you cannot exit and the grade dies on the spot. If it clears, you get the effective tax — the number that actually came back, not the one the contract advertises.
Advertised tax and effective tax are different numbers, and the gap between them is where the money goes. Trust the one we measured.
Five sells, from small to large.
A single-size honeypot check misses the two most common traps: a max-sell limit that only bites above a threshold, and a tax that escalates with size. Both let a small test sell sail through while your actual position is stuck. So we simulate selling at five positions and report where it starts to revert. Green clears cheap; red reverts.
Read it as your real exit window. If the ladder goes green-green-red-red-red, you can leave with a small bag and not a large one — which means the position you're considering may already be too big before you've opened it.
“Sells revert at every size” has two causes: the code blocks selling, or the pool has already been drained to nothing. Different stories, same fact for you — there's no way out.
What the owner could still do to you, decoded from bytecode.
We read the runtime bytecode — which works even when the contract was never verified — and scan its dispatcher for known levers: blacklist, pause, mint, fee and limit setters.
The honeypot test says what happens now; this says what could happen later. A token that simulates perfectly and has a live blacklist function is a token that is fine until the owner decides it isn't. Renounced ownership is what turns this panel quiet.
What this contract is, and what its siblings did.
The registry's read on this token: its shell's class, how many copies exist and across how many wallets, and — the part that decides it — how many of those siblings' pools are already empty, with their median age at death.
Keyed on bytecode alone, so it answers even when we don't know the deployer, and it answers the second the token exists. Unlike price, holders, or even our own sell test, this panel needs no history from the token itself — only from its family. It is the only thing on the page that can warn you about a token that is thirty seconds old.
How many times has this exact wallet shipped this exact contract?
Walks every other token the deployer launched in our index and fingerprints them. Rug factories reship one template under new names; real projects don't. A wallet whose launches are byte-identical to each other is running a production line, and the current token is the next unit off it.
Where The Shell asks “what is this contract, and who else uses it”, this asks “what does this person do for a living”. Both can fire on the same token; either alone is enough to matter.
For a four.meme token: everything that happened before anyone could see it.
When it was minted and by whom, how many distinct wallets bought in on the curve, how long the curve took, and what it raised against its own target.
Worth most in the minutes right after graduation — which is exactly when the DEX side has nothing to say, because the chart is four candles long. This panel is the difference between “new token, who knows” and “filled by six wallets in ninety seconds, and here they are”.
The habits that make the difference.
The same token, read badly and read well.
A token appears on the trending board. It's up 236% in an hour, the chart is a staircase, and the third-party security check is green. The naive read: momentum plus a clean bill of health.
The manual's order says otherwise. Exit ladder: green at the smallest size, red at the other four — so the 236% is real and unreachable. The Shell: byte-identical to a shell with eleven previous tokens, nine of them in pools now under $300, median death at four hours. Life before the DEX: the curve filled in ninety seconds across six distinct wallets.
None of that contradicts the green check, and that's the point — the check read the token alone, and the token alone is fine. Every fact that condemns it lives in its family, its curve, and our own sell test. The chart was the only honest thing on the page and it was still useless.
Why the numbers move, and what's running.
Counts on this site go up as we index more, and they can go down: a pool that drains stops being alive, and a token that dies leaves the active set. Neither is a bug. The registry's totals in particular grow every block, which is why this manual describes them rather than quoting them.
Simulations are point-in-time. An exit ladder that was green an hour ago is not a promise about now, because reserves move and owners act. Re-run it before you rely on it.
What's for sale, and what isn't.
You can pay in BNB to lift a token in Trending or take the banner slot. Payment is verified on-chain and the placement goes live the moment it confirms. Boosts are a multiplier on the score, not a replacement for it, and a boosted row is always labelled as one.
Paying does not buy a verdict. A boosted token carries the same flags as any other, and the screener's veto doesn't care who paid. If we'd call it a rug for free, we'll call it a rug for money.
The limits, stated plainly, because a tool that hides them is worse than one that has them.