Docs

Most launchpads give you a ticker and a prayer. esse gives your coin a rulebook it carries everywhere. No wallet above 2% of supply. No selling in the first ten minutes. Trading only on weekdays, like a proper stock. You pick the rules, and from then on the coin itself turns away any transfer that breaks them

There is no bot watching the chart and no website that could quietly stop caring. Solana runs the check inside the transfer, so a trade that breaks a rule simply never happens. Stack blocks from a catalog of 79, tune every number, play a buy through the stack before you sign, or write rules of your own in a language that reads like English. Coins trade on a Meteora bonding curve and graduate to a real pool when it fills

Every esse coin is a Token-2022 mint with a transfer hook. The mint names the esse hook program, and Token-2022 calls it on every single movement of the coin: buys, sells and wallet-to-wallet sends. The hook reads the moment (who sends, who receives, how much, what they hold, what time it is, the live market cap on the curve) and runs the coin's rules against it. One rule says no, and the whole transaction fails. Nothing moves, not even a little

All coins share one program. Each coin's rules compile to a few dozen bytes of bytecode, stored in the coin's own config account. The program verifies that bytecode once, at the seal, so it can never trip over its own feet on a transfer later

• Rules can't be switched off, not by you and not by esse. Only graduation lifts them, when Meteora moves the coin to its open pool
• Rules start counting at the seal. Until then only the creator's own coins move, so nobody sneaks in ahead of the rules
• From the seal on the creator is inside the rules like everyone else. A block that treats the creator differently, like Dev on a leash, says so in its own line
• While the rules are on, each wallet keeps the coin in its main (associated) token account, so a per-wallet limit counts every wallet once and can't be split across spare accounts
• The same compiler and interpreter run in your browser and in the program; every catalog block is replayed through both in our tests

Five steps from an idea to a coin that trades everywhere, playing on a loop

1. Name, ticker and image, with an optional story and links to X, Telegram and your site. Supply is 1,000,000,000, or 21,000,000 sold in halving eras, with 6 decimals; percents in the rules are shares of it
2. Rules: a preset, a stack of up to 8 blocks from the catalog, or your own lines
3. The curve: where it opens, where it graduates and its base fee
4. Sign. Your wallet creates the coin and its Meteora pool, registers it with the hook, uploads the rules and seals them for good

Plan for roughly 0.1 SOL of rent and network fees. If a step fails nothing is lost: press the button again and it picks up exactly where it stopped. esse never holds your keys, not for a second

Coins trade on a Meteora dynamic bonding curve, paired with SOL or with any other token: a stablecoin, a tokenized stock, a pre-IPO share. Every buy pushes the price up the curve, every sell lets it slide back. When the curve reaches its graduation market cap, Meteora moves the liquidity into a DAMM v2 pool, locks it there forever, and lifts the hook in the same step. From then on the coin trades like any other token, everywhere

The hook reads the curve in the pair's own currency, so on a USDC pair the rules count USDC: a block set to 150 SOL becomes the same value in USDC at the moment of launch, and stays that number. Curve shapes go two ways: one smooth curve, or a Halvening curve of eight eras where each holds half the liquidity of the last. A permanent curve sets graduation so far away that it never fills, and the rules never lift

Next to its curve a coin can have an esse pool, a plain constant-product pool that anyone can provide liquidity to and that pays its LPs 0.3% of every swap. Every move of the coin through it is a real hooked transfer, and the hook counts the pool as a venue: coins going in are a sell, coins coming out a buy. So the rules hold there too, for traders and LPs alike, and nobody can use the pool to step around them

And the moment it fills, three things happen in one go:

Every coin page lists its rules in plain words and runs your trade through them before you sign. A refusal shows up on screen before it can cost you a fee, with the rule that said no and, when time is all it takes, a countdown to the moment it opens. When the countdown hits zero, the button wakes up by itself

Rules that read an account's history (time since its last buy, how many sells it made) need a small record for the token account; the esse swap builder adds it to the transaction for you. A refused transfer fails with error 6100 plus the number of the rule, so wallets and bots can tell exactly why

Each curve has a base fee, picked at launch and frozen with the pool. One percent is the usual choice. Blocks marked “in the curve” shape that fee, like a launch fee that decays over the first hour. The creator's share of the curve fee will fund the keeper blocks once the keeper runs. Launching costs only rent and network fees. esse takes no cut: past Meteora's protocol share, the whole curve fee is the creator's

Here is a small rulebook: buys capped at 1% of supply, ten minutes of patience before selling, three sells per wallet, ever. Trades keep flying in and the rules light up one by one, exactly in the order the hook runs them on chain

Every block wears a badge that says how it is enforced:

• on-chain, 45 blocks: Checked by the esse hook on every transfer
• in the curve, 5 blocks: Set in the Meteora curve itself
• keeper, 0 blocks: Paid out of the creator fee by the esse keeper
• soon, 29 blocks: Designed, not switched on yet

Browse the catalog

A coin can carry up to 8 blocks. They compile into one program and run top to bottom on every transfer; the first rule that refuses ends it. The builder warns about stacks that fight each other (two venue locks that leave no way to move the coin, several wallet caps at once) and lets you play a buy, sell or send through the stack before you sign

Here is what the coin actually stores: your words go in, a few dozen bytes come out, and the seal closes on them

One rule per line. A rule either refuses a transfer when something is true, or requires something to be true. # starts a comment

refuse if is_buy and amount > 1%
refuse if is_sell and sender_seconds_since_buy < 15m
require weekday < 5 and hour_utc >= 13 and hour_utc < 21
refuse if is_sell and mcap_sol < 150 SOL
require is_sell or receiver in [Addr1..., Addr2...]

• 1.5% is a share of total supply
• A plain number next to a token amount is whole tokens: amount > 5000000 means 5M tokens
• Durations take s, m, h, d; SOL amounts take SOL
• and, or, not, brackets, < > <= >= == !=, and + - * / % on numbers
• sender is X, receiver in [X, Y] and signer is not X check wallets
• Arithmetic never overflows: it stops at the largest number, below zero becomes zero, and dividing by zero gives zero

Limits per coin: 32 rules, 1024 bytes of compiled code and 16 named wallets. The compiler explains every line in plain words and points at the exact spot when something is off

Everything a rule can read about a transfer, live, at the moment it happens:

Everything the site does goes through an open HTTP API, no key needed. Amounts are raw units sent as strings: lamports on a SOL pair, the pair token's own decimals on any other, and 6 decimals for the coins themselves. Build a bot, a dashboard or a Telegram alert, nobody needs to ask permission

• POST /api/rules/check Compile rules: bytes, plain-word reading or the exact error
• POST /api/rules/simulate Run rules against a made-up transfer and see which line refuses it
• GET /api/coins Every coin with its rules, market, the latest trades and refusals
• GET /api/coins/{mint} One coin, its trades and refusals; ?view=candles&tf=60 or ?view=holders
• POST /api/swap/check Would this buy or sell land? The real transaction, simulated, with the refusing rule in plain words
• POST /api/swap/build An unsigned buy or sell with every hook account resolved
• GET /api/coins/{mint}/comments Comments, each signed by its author's wallet
• GET /api/wallet/{address} A wallet's bags across every coin, and the coins it launched
• GET /api/quotes Every pair a coin can launch against, with its mint and a dollar price; ?mint= resolves any token
• GET /api/fees/{address} The curve fees waiting for a creator, coin by coin
• POST /api/fees/claim An unsigned claim of a coin's curve fees, for its creator
• GET /api/market Stacks real coins launched with, and signed community rules
• GET /api/analytics Volume, launches, traders and refusals; ?range=24h or all
• GET /api/pools Every esse pool: reserves, price, liquidity, volume, LP fees and yield; ?owner= adds your share
• POST /api/pools/{create|add|remove|swap} An unsigned pool transaction, simulated first; a refusal names the rule

• The esse hook program, which will be open source. Its upgrade authority is how new signals get added, so you trust the team not to change how existing ones behave; the plan is to hand it to a multisig with a time lock
• Meteora, for the curve and graduation
• Not the website. It holds no keys, can't pause a coin and can't change a rule. If the site vanished tomorrow, every coin would keep enforcing its rules