Overview
Township is a launchpad on Pons V2. A coin launched here comes with a treasury of its own, and the trading fees that would normally land in the creator's wallet land in that treasury instead.
On this chain a memecoin's price rests on belief, and belief runs out before liquidity does. The creator earns a cut of every trade and carries it away; nothing accumulates underneath. Township changes exactly one thing about a launch: the destination of that cut.
What follows from that one change is the whole product. The treasury fills up as the coin trades. Any holder can burn tokens and take the matching share of it. Divide the treasury by the supply and you get a floor: not a forecast, not a promise, but a number anybody can compute from chain state and claim on demand.
Lifecycle of a township
- Sign. The founder picks a levy, a reserve asset and an optional cut for themselves, then signs. Those choices become the charter and are fixed at that moment.
- Launch. One transaction deploys the treasury and calls the Pons V2 factory, passing the treasury as the creator fee recipient and the levy as the creator tax. The coin lands on the Pons curve like any other launch.
- Trade. Every buy and sell pays the levy. It accrues in the Pons fee ledger to the credit of the treasury, in the quote asset, from the very first trade.
- Collect. Anyone may call
collect()to move the accrued fees from the ledger into the treasury. Declared shares are taken out of that inflow at that moment; the rest stays. - Graduate. When the curve crosses its threshold, the coin moves into a locked Uniswap V4 pool. The same treasury remains the fee recipient, so the levy keeps flowing.
- Redeem. At any point a holder can burn tokens and receive the matching share of everything the treasury holds.
The charter
Five articles, chosen once, then held by a contract that has no owner and no way to rewrite them. A sixth appears only when the founder takes a position in their own coin. This is what the founder signs.
| Article | What it decides | Range |
|---|---|---|
| 01 · Levy | The trade tax paid into the treasury on every trade | 1% – 10% |
| 02 · Reserve | What the treasury fills with: a tokenized stock, ETH or a stablecoin | any approved asset |
| 03 · Redemption | Burn tokens, take the matching share of the treasury | always on |
| 04 · Founder cut | How much of the levy stays with the founder | 0% – 50% of the levy |
| 05 · Lock | Nobody can spend the treasury; redemption is the only way out | always on |
| 06 · First buy | What the founder bought of their own coin in the launch transaction | 0, or an amount |
Articles three and five have no setting in version one, and that is deliberate. A treasury you can drain is not a floor, and a redemption you can suspend is not a right.
Article six is written only if it happened. The founder may buy into their own township in the launch transaction, through the same curve and at the same price as everyone else; the factory sends those tokens straight to them and never holds any itself. When the amount is zero the article does not appear, because an article that says nothing on every launch is decoration, not disclosure.
Levy
The levy is an additional trade tax layered on top of the Pons curve fee. Pons pays it to the creator fee recipient in full and never splits it with its own protocol. Because our factory always sets that recipient to the coin's treasury, the levy lands under the coin by construction, not by promise.
It is charged in the quote asset, not in the memecoin, and it applies both while the coin is on the bonding curve and after it graduates into its Uniswap V4 pool.
Reserve
The reserve is what the treasury is made of. It is chosen at launch and cannot change afterwards.
The important detail is that the coin trades in a pair with its reserve. Pons lets a launch pick an arbitrary approved quote asset, so a township paired with NVDA collects NVDA from the first trade onwards. There is no buying round, no oracle, no swap step and nothing to time: the treasury fills with the asset itself.
| Kind | Examples |
|---|---|
| Tokenized equity | NVDA, AAPL, TSLA, GOOGL, META, AMZN, PLTR |
| Index | SPY, QQQ |
| Crypto | ETH |
| Stable | USDG |
The floor
The floor is the treasury divided by the token's total supply, which includes tokens still held by the Pons curve or pool (see Sharp edges).
floor per token = treasury holdings / totalSupply
Two properties make it worth putting on the page.
It only goes up from trading. Every trade adds to the treasury and nothing removes from it except redemption.
Redemption does not lower it. A redeemer burns a fraction of supply and takes exactly that fraction of the treasury. Both sides of the ratio shrink by the same proportion, so the floor for everyone still holding is unchanged. This is asserted in the test suite, not just in prose.
Redemption
Redemption is a two step flow, because ERC-20 requires an allowance before a contract can burn on your behalf.
token.approve(treasury, amount)
treasury.redeem(amount)
The treasury computes your share before burning:
yourShare = holdings * amount / totalSupply
then burns the tokens and transfers the reserve and any native balance to you. There is no deadline, no vote, no unlock window and no queue. Partial redemptions are allowed; you can burn any amount you hold.
Where every basis point goes
The levy is split once, at the moment it is collected, and only ever out of the newly arrived amount. What already sits in the treasury is never touched by the split.
A worked example. A township sets a levy of 5% and a founder cut of 20% of that levy. Our protocol share is a flat 10% of the levy, named in the charter.
| On $100 traded | Amount | Goes to |
|---|---|---|
| Levy | $5.00 | collected by the treasury |
| — founder cut | $1.00 | the founder, 20% of the levy |
| — protocol share | $0.50 | Township, 10% of the levy |
| — stays under the coin | $3.50 | the treasury |
With the default founder cut of zero, $4.50 of every $5.00 stays under the coin.
Built on Pons V2
Township is a launchpad with its own contracts, and it launches through Pons rather than around it. The coin trades on the Pons curve, shows up in the Pons feed, and is visible to every terminal and bot already watching that chain.
| What we use from Pons | How |
|---|---|
creatorFeeRecipient | A launch parameter separate from the deployer. We set it to the treasury. |
creatorTaxBps | The creator chosen trade tax. We set it to the levy. |
pairToken | The quote asset. We set it to the reserve, so the treasury collects that asset directly. |
| Fee escrow | Where fees accrue. The treasury claims from it. |
| Snipe tax | 99% at launch, decaying to zero over 3 seconds (snipeTaxStartBps, snipeTaxSeconds on the curve). Charged against whoever receives the tokens; the launching factory is exempt. 70% of it reaches the treasury, 30% goes to Pons, swept by a Pons keeper a few hundred blocks later. |
| Graduation | Handled entirely by Pons. The fee recipient carries over to the V4 pool hook. |
We do not fork Pons, do not proxy its trading, and do not hold any position in its pools.
Contracts
| Contract | Address | Role |
|---|---|---|
| TownshipFactory | not deployed yet | Deploys a treasury and launches the coin in one transaction |
| Treasury | one per township | Holds the reserve, splits the inflow, serves redemption |
| Pons V2 factory | 0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e | External. Creates the token and the curve |
| Pons fee escrow | 0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e | External. Where the levy accrues |
Network: Robinhood Chain, chain id 4663. Explorer:
robinhoodchain.blockscout.com.
Both Pons addresses above were read from the chain, not copied from documentation:
feeEscrow() and maxCreatorTaxBps() were called on the factory itself.
Function reference
TownshipFactory
| Function | What it does |
|---|---|
launch(params, terms, extra) |
Deploys the treasury, launches through Pons, optionally makes the founder's first
buy on the curve, records the charter, emits TownshipLaunched |
Terms | The charter as one argument: config id, pair token, reserve, levy, founder cut, first buy and its slippage floor |
charterOf(token) | The full charter of a township: treasury, curve, reserve, levy, founder cut, founder, timestamp |
townships(i) · townshipCount() | Enumerate every township ever launched here |
Treasury
| Function | What it does |
|---|---|
collect() | Pulls accrued fees from the Pons escrow, pays the declared shares out of that inflow. Callable by anyone. |
redeem(amount) | Burns your tokens, transfers your pro rata share of every asset held |
holdings() | Native and reserve balances held right now |
floorPerToken() | Floor per token, in native and in reserve units |
token · reserve · founder · founderCutBps · protocolShareBps |
Immutable charter terms, readable by anyone |
There is no withdraw, no sweep, no rescue, no
transferOwnership and no upgradeTo. That absence is asserted by a
test that walks the contract interface and fails if any of them ever appear.
What holds the charter
Not our good intentions. Four structural facts, each verifiable in the source:
- No owner. The treasury has no owner, no admin and no roles. There is nobody who could be persuaded, phished or subpoenaed into moving the funds.
- No withdraw path. The only way value leaves a treasury is
redeem, and it always pays the caller their exact pro rata share. - No upgrade. The treasury is not a proxy. The code that exists at launch is the code that will be there in a year.
- Set once. The token, the reserve, the founder cut and the protocol share are immutable constructor arguments. The factory can name the token exactly once.
Evidence, not an audit
Nobody outside this project has reviewed the code. What exists instead is listed here, so you can weigh it yourself, and every line of it can be checked.
| Evidence | What it shows |
|---|---|
| Verified source | The current factory, the one before it and the treasuries of both SPIRE townships are verified on Blockscout: the code running on chain is the code published there. |
| 19 unit tests | No withdraw path in the treasury, the founder cut taken only from new inflow, redeem paying an exact pro rata share, the floor unchanged after a redeem, the first buy reaching the founder, and the calldata this site writes by hand. |
| Fork tests | Run on a copy of the live chain, against the real Pons rather than a mock: a launch through the Pons factory, the founder's first buy at 100% of the fair amount, and a collect followed by a redeem on a real township, SPIRE #2, with its real coin, treasury and escrow balance. The holder was paid their exact share and the floor for everyone else did not move by a single wei. |
| On the live chain | Four townships launched through Township factories.
collect() has run three times on SPIRE #1, and its treasury holds the
result. |
What has not happened on the live chain yet:
- No redeem has been sent. It has run only on a fork, with a real coin and a real treasury. A fork run is strong evidence, but it is not a receipt.
- No township has launched through the current factory. The fixed first buy has been proved on a fork only.
- No township has graduated. The fee recipient carrying over to the Uniswap V4 pool is Pons behaviour we have read in its code, not watched happen.
Sharp edges
Things that are true about Township by design or by circumstance, and that you should know before you put money in.
- The floor is spread over the whole supply. Redeem divides by
totalSupply, and that includes the tokens still held by the Pons curve or, after graduation, by the pool. Those tokens are never redeemed, so early on a holder's share is far smaller than the treasury divided by the tokens in wallets. On the fork, burning 14,880 SPIRE against a supply of one billion paid 0.000000044 ETH. - Redeem counts only what is already in the treasury. Fees still waiting in
the Pons escrow are not part of anyone's share until they are collected. The coin page
handles this: when anything is waiting, its redeem button collects first, at the cost of
one more signature. If you redeem straight from the explorer, call
collect()first, or your part of it stays behind for the other holders. - The founder buys first. The first buy happens inside the launch transaction, before anyone else can trade, at the curve's opening price. It is disclosed as article six with the exact amount, but it is an advantage by construction.
- No anti-bot guarantee. The Pons snipe tax makes the first three seconds expensive and sends most of what it takes to the treasury. It does not identify people and cannot stop someone spreading buys across many wallets once the window has passed.
- Part of the flow runs on Pons's schedule. The treasury's share of the snipe tax reaches the escrow only when a Pons keeper sweeps the curve, a few hundred blocks later. We do not run that keeper.
- Old townships keep old flaws. Townships launched before the first buy fix stay on the factory that made them. The founder of SPIRE #2 kept about 1% of their first buy, and nothing can change that afterwards.
- Nothing can be corrected. No owner also means no fix. A mistake in a signed charter or a bug in a deployed treasury stays for the life of the coin. A new version means a new factory, and existing townships do not move to it.
- The site is a convenience, not the contract. Pages read the chain through public RPC nodes that rate limit bursts. The site paces its reads and falls back to a second node, but if a page still shows nothing, the explorer is the source of truth, and every treasury function is public and can be called without this site.
What we cannot promise
What this means in practice: our contracts cannot redirect your levy, and neither can the founder. Pons can, with three days of public notice. If that ever happens to a township launched here, the pending change is visible on chain the moment it is proposed, and we will publish it before it executes.
Other things we do not claim:
- We do not promise a price. The floor is a claim on assets, not a bid on the market.
- We do not promise the reserve holds its value. A tokenized equity can fall; so can ETH.
- We do not custody anything. Every treasury is its own contract, and we cannot touch it.
Risk
The contracts are not audited. They are small, deliberately, and covered by a test suite that asserts the properties above, but small and tested is not the same as audited. Treat early townships accordingly. What we have instead is listed under Evidence, not an audit.
Beyond our code, the usual chain risks apply: a bug in Pons, a bug in Uniswap V4, a failure of the tokenized asset issuer, or a chain level incident would all reach your township regardless of how our contracts behave.
Rewards denominated in tokenized equities are issued by third parties and may be restricted in your jurisdiction. Nothing here is investment advice.
Glossary
| Term | Meaning |
|---|---|
| Township | A coin launched through this protocol, together with its treasury and charter |
| Charter | The five terms chosen at launch and fixed in the contracts |
| Levy | The trade tax that flows into the treasury |
| Reserve | The asset the treasury is made of |
| Treasury | The per-coin contract holding the reserve |
| Floor | Treasury divided by total supply |
| Redemption | Burning tokens to claim your share of the treasury |
| Resident | Anyone holding the coin |
| Founder | Whoever signed the charter |
Status
| Piece | State |
|---|---|
| Contracts | 19 tests passing, plus fork tests against the live Pons and a real township |
| Factory on chain | deployed · — |
| Source verification | verified on Blockscout |
Charter signing · /create | live, including the founder's first buy |
Township pages · /t/… | live |
The map · /map | live |
| Treasury contracts | verified for both SPIRE townships · one is deployed per township |
| Collect on the live chain | done · three collects on SPIRE #1 |
| Redeem on the live chain | fork only · never sent on the live chain |
| Audit | none |
This page is updated as pieces land. If a row says it is not built, it is not built.