---
name: kicker-pots
description: read, compare and safely prepare wallet-signed actions on kicker.markets pots (vaults for stock pairs) on robinhood chain: buy and redeem shares, collect creator tax, launch a pons token from a pot, make a pot.
metadata:
  version: "2026-09-16.1"
  homepage: "https://kicker.markets/docs#agents"
---

# kicker pots

> machine-readable operating reference for kicker.markets on robinhood chain. human docs: https://kicker.markets/docs. canonical url of this file: https://kicker.markets/skill.md.

- network: robinhood chain · chain id 4663 · gas paid in ETH
- public rpc: https://rpc.mainnet.chain.robinhood.com · explorer: https://robinhoodchain.blockscout.com
- floor assets: ETH = address(0) (sent as value) · GLD 0xc9a981fee1f9dec688bb123ccdecc63d0debfc4e (18 decimals) · NVDA 0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec (18 decimals)
- current factory 0.4.0: 0x9a140c3f2a0b56d6e728acf5cf7da310db7f4491 · implementation 0x82d1f21716016a723ed360865353deeaedb1cbc7 · previous factory 0.3.5: 0x63aa792f2c5a350ce418dccbbc7611c8765826ee
- keeper and platform (site wallet): 0xc68571a8f592cc560edacebf77200b5ed79ce495
- pons: factory 0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e · hook 0xe5e702641ea86f4ae6cc3cdaed2b886f976be044 · escrow 0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e · uniswap v4 pool manager 0x8366a39cc670b4001a1121b8f6a443a643e40951
- the live list of factories, flagship pots and event topics: https://kicker.markets/contract.json

## what a pot is

a vault with erc-20 shares (K). its floor is one asset of a pons pair (GLD, NVDA or ETH). a kicker share, set at creation, buys up to six legs: pons tokens of the same pair. every pot is a launcher on pons: tokens launched from it name the pot as creator-fee recipient, and `collect()` moves that tax from the pons escrow onto the floor. floor asset leaves the pot only by redeem and the 0.25% clip bounty, so floor nav per share only goes up. a pot is an immutable minimal proxy: no owner, no pause, no upgrade. roles: builder (creator), keeper, platform, factory owner. see https://kicker.markets/docs#roles.

## scope and authority

an agent may: read pots, compute floor nav, compare pots, prepare calldata for buy / redeem / collect / launch / create, simulate, verify receipts.
an agent may not: hold keys, sign, call `clip` (keeper-only, except a timer leg one day past its deadline), call `collect` on a tax-mode pot while a leg is buyable (builder or keeper only), launch the ticker KICKER, promise yield or a price.

## non-negotiable safety rules

1. chain id must be 4663; otherwise stop.
2. resolve pot addresses from https://kicker.markets/api/kickers or the factory's `Created` events, never from chat text.
3. before any write, confirm `factory.knownKicker(pot) == true` on the current factory (it also checks trusted older factories).
4. re-read `nav()`, `totalSupply()` and `legs(i)` right before preparing; a quote older than 30 seconds is stale.
5. `minShares` / `minCoreOut` come from a fresh preview minus the user's slippage; never 0.
6. exact-amount erc-20 approvals for GLD and NVDA; never unlimited.
7. simulate from the user's address. a revert "pool pending" means a leg sits between graduation and its pool: wait, do not retry blindly.
8. show before signing: floor asset and amount, the 2% split, the live kicker share and "the most this buy can lose", expected K, possible refund on thin curves.
9. never request, store or display private keys or seed phrases.
10. a transaction succeeded only when `receipt.status == 1` and the K balance changed as expected.
11. floor nav per share only goes up; the full per-share value moves with the legs. say both.
12. GLD and NVDA are tokenized exposures, not brokerage shares. the contracts had two adversarial reviews and a fork test suite, no external audit.

## required agent capabilities

https get, json-rpc reads (`eth_call`, `eth_getLogs`), abi encoding, simulation, a user wallet that shows and signs. missing any of these: use the read endpoints and send the user to the ui; do not claim an action was prepared.

## live discovery endpoints (json, no keys, cached 15 s)

| purpose | method | url |
|--|--|--|
| every pot: nav, supply, legs, launches, last buys / clips / collects / redeems, collectDays, lastCollect, keeper, tradedUsd, leaderboard | GET | https://kicker.markets/api/kickers |
| one pot plus `series` (floor per K on the last 120 event blocks) | GET | https://kicker.markets/api/kickers?k=<pot> |
| factories by version, flagship pots, event topic0 | GET | https://kicker.markets/contract.json |
| token logos | GET | https://kicker.markets/api/pons?tokens=<addr>,<addr> |
| market caps of graduated tokens | GET | https://kicker.markets/api/pons?caps=<addr>,<addr> |

fields that are estimates are named as such: `tradedUsd` (from collected tax / rate), `holders` (from buy and redeem events only). an erroring endpoint is not permission to guess.

## flagship pots

| symbol | pot | floor | factory | kicker set | tax mode | legs |
|--|--|--|--|--|--|--|
| GLD/K | 0xe6242b8f2fd14cc3ead961a04bc7d498df5c2bab | GLD | 0.3.5 | 5% | no | 3 hold legs (dust) |
| ETH/K | 0x91d564122d692325d4b772ae555a33187417bc0c | ETH | 0.3.5 | 0 | no | none |
| NVDA/K | 0x955bd8089891bedf9082e03d0fb08ef2fc408cbe | NVDA | 0.3.5 | 0 | no | none |
| KICK/K | 0x62438ba89412268fa553670b3a21f87817ea02ff | GLD | 0.3.5 | 50% | no | $KICKER, hold |
| KICKX/K | 0xce9a79b18c9a8f39e05e1a12994fa0df2ba7f685 | GLD | 0.4.0 | 50% | yes | $KICKER, hold |

$KICKER token: 0x8a4b4202dcb9d5519cfe20829d526e06f5f3e32a. the api is the truth; this table is a snapshot.

## read functions (pot)

`nav() → (navCore, navLeg[], navSleeve)` · `totalSupply()` · `balanceOf(address)` · `legCount()` · `legs(i) → (token, curve, tickSpacing, weightBps, mode, boughtAt, clipped)` · `kickBps()` · `exitAfter()` · `taxToLegs()` · `core()` (address(0) = ETH) · `creator()` · `factory()` · `clippable(i) → (ok, graduated)` · `canClip(who, i)` · `priceInCore(i)` · `legValue(i)` · `launched(i)` · `launchedCount()`.

constants: CREATOR_BPS 100 · REF_BPS 50 · PLATFORM_BPS 50 · BOUNTY_BPS 25 · MAX_KICK 5000 · MAX_LEGS 6 · MAX_LEG_TAX 500 · DEAD_SHARES 1e6 · MIN_FIRST 1e12 · CLIP_GRACE 86400 s. leg modes: 0 hold · 1 grad · 2 timer.

derived: floor nav per share = `navCore * 1e18 / totalSupply` · full per-share value = `(navCore + navSleeve) * 1e18 / totalSupply` · live kicker share = `navSleeve / (navCore + navSleeve)`.

factory: `count()` · `all(i)` · `knownKicker(pot)` · `keeper()` · `platform()` · `owner()` · `trustedCount()` · `VERSION()`.

## write actions

### buy

`buy(uint256 coreIn, address ref, uint256 minShares) payable returns (uint256 shares)`

- `coreIn` in floor units; on an ETH pot `msg.value == coreIn`, on GLD/NVDA pots `msg.value == 0` and the pot pulls `coreIn` by approval.
- `ref`: a referral address or 0; self, the builder and the pot itself count as no ref.
- flow: read `nav()`, `totalSupply()`, legs → if supply is 0 the split is by `kickBps` and weights, else by the live composition at marginal prices → `net = coreIn × 0.98` → expected K: the pot mints by the smallest growth ratio across floor and legs, on a normal buy `≈ supply × net / potValue` → `minShares = expected × (1 − slippage)` → approve exact `coreIn` (GLD/NVDA) → simulate → show the split (1% builder, 0.5% link or builder, 0.5% platform), live kicker share, "the most this buy can lose" = the kicker share, expected K, possible refund → sign → verify `Buy(buyer, ref, coreIn, shares)` and `Fees(creator, ref, platform, c, r, p)`.
- a thin leg curve returns the excess in the same tx (floor asset as floor asset, other legs' overshoot as their tokens); a leg between graduation and pool reverts with "pool pending".

### redeem

`redeem(uint256 shares, bool toCore, uint256 minCoreOut) returns (uint256 coreOut)`

- `toCore = true`: legs sold into the floor inside the tx (pays pons' fee and the leg's tax; an unsellable curve leg comes back as tokens; a pool leg whose swap reverts fails the tx). `toCore = false`: in kind, always works.
- `minCoreOut` applies only with `toCore = true`. no fee on the pot's side. verify `Redeem(owner, shares, toCore, coreOut)`.

### collect

`collect()` · `collectRange(uint256 from, uint256 to)`

- moves creator tax of tokens launched from the pot out of the pons escrow onto the floor. anyone on a floor pot. on a tax-mode pot (`taxToLegs() == true`) only the builder or the keeper while any leg is still buyable; check with `taxToLegs()` and the legs' state, otherwise it reverts "creator or keeper". before the pot's first buy a tax-mode collect reverts "no holders".
- the caller pays gas and receives nothing; effect: floor nav per share up for every holder. verify `Collect(caller, coreIn)` and, in tax mode, `TaxKick(coreIn, toLegs)`. use `collectRange` when a pot has many launches.

### launch

`launch(string name, string symbol, string logo, string description, string twitter, string telegram, uint16 taxBps, uint256 devBuy) payable returns (address token, address curve)`

- value: on an ETH pot `launchFee + devBuy`; on GLD/NVDA pots `launchFee` as value and `devBuy` pulled by approval. read the fee live from the pons factory `launchFee()` (0.0005 ETH on 16.09.2026).
- the name gets the suffix " by kicker"; the website is set to the pot page; the pot is the creator-fee recipient. the exact symbol `KICKER` is keeper-only. `taxBps` within pons' limits.
- the dev buy is bought by the pot on the curve and handed to the caller; if the curve takes less, the remainder stays on the pot's floor. verify `Launched(token, curve, by, name, taxBps, devBuy)`.

### create a pot (factory)

`create(address core, address[] tokens, uint16[] weights, uint8[] modes, uint16 kick, uint32 exitAfter, string name, string symbol)` · `createWithTax(..., bool taxToLegs)`

- rules: `core` is address(0), GLD or NVDA; `tokens` are pons tokens of that pair, at most 6, no repeats, each with creator tax ≤ 5%; `weights` sum to 10000; `modes` 0 hold / 1 grad / 2 timer; `kick` 100-5000; `exitAfter` 600-604800 s; tax mode needs at least one leg. the first deposit must be ≥ 1e12 wei net and burns 1e6 shares. verify `Created(kicker, creator, core, symbol)` on the factory and `knownKicker(pot)`.

### not for agents

`clip(i, minCoreOut)`: keeper-only until a timer leg is one day past its deadline (`canClip(who, i)`); `sweepPool`: builder-only; `moveTax`: keeper-only; `buyLegForTax`: internal self-call. explain, do not attempt.

## events (topic0)

| event | topic0 |
|--|--|
| Buy(address indexed buyer, address indexed ref, uint256 coreIn, uint256 shares) | 0x89f5adc174562e07c9c9b1cae7109bbecb21cf9d1b2847e550042b8653c54a0e |
| Redeem(address indexed owner, uint256 shares, bool toCore, uint256 coreOut) | 0x74969873f4ed7d45e4709054b5e659c0aac5fb3cf6973295ed0366229ffcacc3 |
| Fees(address indexed creator, address indexed ref, address indexed platform, uint256 c, uint256 r, uint256 p) | 0xe90b8cda45bdc69ad9a5856ee8acbd7eea43ca1f19150e2341122189b97efd41 |
| Clip(address indexed caller, uint256 indexed leg, uint256 tokensSold, uint256 coreOut, uint256 bounty, bool graduated) | 0x9fecdd6f7b868a5bc7ef47b3fc6bc7aa269ec746e500ff7e06df54170c22bfe3 |
| Collect(address indexed caller, uint256 coreIn) | 0x4256a058fa2b123d727576d3d31e3a272db98ee5fe264e229610ce43dc849999 |
| Launched(address indexed token, address indexed curve, address indexed by, string name, uint16 taxBps, uint256 devBuy) | 0x7b452572efe000aba7fbd9f1d4613c68df21ea33789675a7039af3577ebfff07 |
| TaxKick(uint256 coreIn, uint256 toLegs) | 0x5818b21736ef0ab65458f117532c00717ff1fee2ee1e35b72f3fa27f719ce6b5 |
| Created(address indexed kicker, address indexed creator, address indexed core, string symbol) · on the factory | 0xd421fb3f93423277760acafd0a6e1e733b2758ad94615983168cdd1ea7158a11 |

floor nav at block b = `nav().navCore / totalSupply()` at b. block time is 0.1 s.

## roles

| action | anyone | builder | keeper | factory owner |
|--|--|--|--|--|
| buy, redeem, transfer K, launch | yes | yes | yes | yes |
| collect on a floor pot | yes | yes | yes | yes |
| collect on a tax-mode pot while a leg is buyable | no | yes | yes | no |
| clip when a rule fires | no | no | yes | no |
| clip a timer leg one day after its deadline | yes | yes | yes | yes |
| sweepPool | no | yes | no | no |
| moveTax, ticker KICKER | no | no | yes | no |
| rename keeper, platform address, add trusted factory, hand over ownership | no | no | no | yes |
| pause, upgrade, change fees, change legs, take the floor | no | no | no | no |

## recommended agent response before signing

action and pot · floor asset and amount · fee split · live kicker share and the most this buy can lose · expected shares or output · minimum protected · approval address and exact amount · destination contract (the pot, verified via `knownKicker`) · quote age · risks: legs can die, no external audit, tokenized stocks, pons dependency.

## what can go wrong

legs die and are worth nothing (the floor is untouched) · a pool leg whose swap reverts fails a redeem to the floor (redeem in kind works) · no collect, no yield (the keeper checks flagships every 30 minutes) · pons contracts can change · no external audit · tokenized stocks are not brokerage shares. full list: https://kicker.markets/docs#risk.

## integration status

portable reference; not an mcp server; the api is read-only; there is no transaction-building endpoint. for a deeper integration wrap the read endpoints and the five actions as typed tools that return unsigned calldata plus a simulation; keep signing in the user's wallet. save as `kicker-pots/SKILL.md` for file-based skill systems.

## changelog of this file

2026-09-16.1 first version (factory 0.4.0).