graphrun
$GRAPHRUN not live yet contract at launch

Read a launch before you enter it.

Point it at a token on Robinhood Chain. Four lanes run in parallel: what the contract can still do to you, how deep the pool is, who deployed it, and how few wallets hold it. Every check is a contract call, so a run costs nothing and needs no key. It never predicts a price.

CHAIN
Robinhood Chain · 4663
STACK
Arbitrum Orbit L2
COST PER RUN
0 tokens
LICENSE
MIT · one file of config
EXIT CHECKsample launch
CAN YOU EXIT?
CLEAR
the gate opens on how expensive a mistake is to undo, never on how confident anything sounds
graph 4 lanes
splitter cuts the work into 4 units contract · liquidity · deployer · holders · merge code · dedupe on content · 0 tokens gate opens on exit, not on confidence shipped correction learning
terminal sample launches · looping

A loop over sample launches, so you can watch the shape work. graphrun reads real chains on your machine; this page reads nothing.

0
tokens spent per run
4
lanes, in parallel
2
checks that need no key
2
dependencies, that is all
from nothing to a verdict

Five steps. About two minutes.

Python 3.10 or newer is the only thing you need in advance. Steps one to four need no key and no account. Step five adds the two lanes that want an index.

1

Install it

Two dependencies, PyYAML and certifi. Nothing is sent anywhere.

git clone https://github.com/hanakoxx/graphrun.git
cd graphrun
pip install -e .
2

Look at the shape first

Draws the graph in your terminal and names the return path you did not build. Run it on a chain config and it will tell you the graph is fast and never gets smarter.

graphrun explain examples/pons-live.yaml
3

Try it on a fixture

The real graph against a deterministic backend. One lane fails on purpose so you can watch a null land in the merge instead of killing the run.

graphrun run examples/pons.yaml --dry
4

Point it at a real token

Put the token address in the config, or build one below. Two lanes read the chain directly and work right now, with no key at all.

graphrun run examples/pons-live.yaml
5

Add the free key for the other two

Who deployed a contract and who holds it need an index. Free tier at dev.blockscout.com, one minute, no card.

export GRAPHRUN_EXPLORER_KEY=proapi_...
graphrun run examples/pons-live.yaml
reference

Every command, every address.

commandwhat it does
graphrun init [path]write a starter config you can edit
graphrun explain <cfg>draw the shape, name the missing return path
graphrun verify <cfg>check a config without running it
graphrun run <cfg>run it. --dry for the fixture, --json for machines
graphrun trace [id]read what a run wrote down. --list for all runs

Defaults point at Robinhood Chain. Override either endpoint with an environment variable and the same graph reads any EVM chain.

GRAPHRUN_RPC_URLhttps://rpc.mainnet.chain.robinhood.com
GRAPHRUN_EXPLORER_URLhttps://api.blockscout.com/4663
GRAPHRUN_EXPLORER_KEYfree at dev.blockscout.com, needed by two lanesget one
chain id4663 mainnet · 46630 testnet · gas in ETH

Inside the contract lane, these are the four bytes it looks for in the deployed bytecode. Every one is computed with keccak256 at runtime, never copied from a table, because a wrong constant fails silently: the call reverts, the lane reports nothing, and nothing reports nothing.

selectorsignaturewhat it means
0x40c10f19mint(address,uint256)supply can grow behind you
0xa0712d68mint(uint256)the same, shorter form
0x69fe0e2dsetFee(uint256)the sell tax can move
0x0b78f9c0setFees(uint256,uint256)buy and sell, separately
0xc647b20esetTaxes(uint256,uint256)the same idea, renamed
0x404e5129blacklist(address,bool)your wallet can be frozen
0x153b0d1esetBlacklist(address,bool)the same, renamed
0x8456cb59pause()transfers can stop
0xec28438asetMaxTxAmount(uint256)your sell size can be capped
0x8a8c523cenableTrading()the market opens when they say
0x8da5cb5bowner()read it, then check for zero
0x715018a6renounceOwnership()present is not the same as called
0x0902f1acgetReserves()how deep the pool actually is
0x18160dddtotalSupply()what the reserves are measured against
what each lane reads

Four lenses. Four isolated contexts.

Give four checks one shared window and they converge: the first finds something, the rest read it, and all four reports centre on the same thing. Each lane here sees only its own slice, which is what makes them return different things.

contract

lane 01

Can the owner still change the rules after you are in. Scans the deployed bytecode for mint, fee switches, blacklists and pause, then checks whether ownership was ever renounced.

needs nothing · reads the chain directly

liquidity

lane 02

Pool reserves, total supply and decimals, read straight from the contracts. The lock check reports not verified rather than guessing, because reading a lock needs the locker contract and that is not wired yet.

needs nothing · reads the chain directly

deployer

lane 03

Who shipped it, how many transactions that wallet has sent, and whether it holds anything. Half a million transactions with an empty balance is a factory, not a person, and that changes what the answer means.

needs a free key · this one wants an index

holders

lane 04

How concentrated the supply is, and whether a single wallet holds more than half of what the explorer lists. Concentration is arithmetic, so it costs nothing once the list is in hand.

needs a free key · this one wants an index
the gate · live in this page

It opens on exit, not on confidence.

On a launch, how bad is this mistake has exactly one translation: can you sell. Move the rules and watch the same findings change sides. This is the real gate logic, running here.

lanes returning

min_lanes

2

blocked_paths

and one more

A sample launch, so the rules have something to bite on. Turn a lane off to see what a graph does when one node times out.

shipped
held
The owner can still mint.
More supply can appear behind you, and you cannot get ahead of it.
The liquidity is not locked.
The pool can leave. There is no exit to be early to.

Neither of those is a threshold set high. They are checks that never pass, no matter how the chart looks. Confidence is the weakest input to this decision, because it is the only one anyone can influence.

config builder

Paste an address. Take the config.

This runs in your browser and touches no network. Drop in a token address and it writes the graph for you, ready to save as examples/my-launch.yaml and run.

TOKEN ADDRESS
PAIR ADDRESS · OPTIONAL, UNLOCKS THE DEPTH READ
what it will not tell you

Where the price goes.

Nothing can, and a tool that implies otherwise is worse than no tool at all. This reads what is in front of you and whether you could get back out. Everything after that is your call. It holds no keys, signs nothing, and never places a trade.

token

$GRAPHRUN, checked by its own tool.

The tool is MIT and works with or without the token. Everything below is read from the chain the same way graphrun reads anything else, and you can run the same four checks on this contract yourself in one command.

price chart at launch
The chart goes live with the pool.
Until then there is nothing honest to draw here.
1B
fixed supply
at launch
liquidity lock
at launch
ownership
at launch
buy and sell tax

Verify the contract address on the explorer before you touch it, and run the four checks on it the same way you would on anything else. That is the whole point of the thing.

PRICE
live at launch
ticker, chain and contract are fixed. price is not something this page will ever guess.
buy on Uniswap Pons
contract published at launch
EXIT CHECKself-audit
?contractat launch
?liquidityat launch
?deployerat launch
?holdersat launch
CAN YOU SELL?
the verdict is published the moment the contract is
graphrun run examples/graphrun.yaml