docs.

the pot

a pot is a vault with shares. its floor is one asset of a pons pair; the flagships and /make use GLD, NVDA or ETH. you deposit the floor asset and get K, an ERC-20 share of the pot. K is transferable and redeemable any time.

a pot may carry a kicker: a slice of the pot, 1-50% at creation, that buys up to six pons tokens of the same pair. those tokens are the legs. the rest stays on the floor as the floor asset. a pot with no legs is a pure floor.

every pot is a launcher on pons. tokens launched from it name the pot as their creator-fee recipient, so their trading tax lands in the pot, not in a wallet. collect() moves it onto the floor. that is what K earns: creator tax, paid in the floor asset.

legs, weights, kicker share and exit rule are fixed at creation. a pot has no owner, no pause, no upgrade. the only outside roles it reads are the keeper and the platform address of its factory. the flagship pots on pons are ours; anyone can make one at /make.

buy and redeem

buy

buy(coreIn, ref, minShares). send the floor asset (ETH as value, GLD or NVDA by approval). 2% comes off the top: 1% to the pot's builder, 0.5% to the referral link (or the builder when there is none), 0.5% to the platform. the remaining 98% is split by the pot's composition at that moment, legs at their marginal price: the floor share stays as the floor asset, the kicker share buys legs on their pons curves or pools. only a deposit into an empty pot (the first one, or one after every holder has left) uses the builder's kicker share, with clipped or dead legs keeping their weight on the floor; every later buy joins at the current mix and never moves it, so nobody is diluted and nobody gets a free ride. the mix itself drifts with the legs' price, with clips, and on tax-mode pots with collects, so the kicker can sit above or below the number set at creation. the pot page and the buy preview show the live split.

you receive K by growth: the pot measures how much the floor and each leg grew from your deposit and mints K by the smallest of those ratios, shares = supply × ratio. on a normal buy that equals your net deposit over the pot's value at marginal prices. a buy never moves floor nav per share. the first buy burns 1,000,000 wei-shares so supply never returns to zero.

if a leg's curve is thin and cannot take its part of your buy, the excess comes back in the same transaction: floor asset as floor asset, the other legs' overshoot as their tokens. you get K for what fit. while a leg sits between graduation and its pool, buys revert; they resume when the pool exists.

redeem

redeem(shares, toCore, minCoreOut). no fee on the pot's side. two ways:

• to the floor: your share of every leg is sold into the floor asset inside the same tx. selling legs pays pons' own trading fee and the leg's creator tax. a curve leg that cannot be sold at that moment comes back as tokens instead of failing the redeem.
• in kind: you receive your share of the floor asset and your share of each leg as tokens. always works.

floor nav

floor nav is the floor asset in the pot divided by K outstanding: navCore / totalSupply. it is what one K redeems to before counting legs. it has three movers and one direction:

• a buy adds floor and mints K at the same rate: per share unchanged.
• a collect adds creator tax to the floor with no new K: per share up.
• a clip sells a leg into the floor with no new K: per share up.
• a redeem removes floor and burns K at the same rate: per share unchanged.

nothing in the contract takes floor out except redeem and the 0.25% clip bounty, paid from the clip's own proceeds, so floor nav per share never goes down. the pot page draws it as a staircase from the first buy. the legs are on top of that: nav() returns the floor, each leg at what selling the whole holding would return (spot for pool legs), and the sleeve total, so the pot's full per-K value can move with the legs while the floor part only steps up.

legs and clips

a leg is a pons token of the pot's pair, bought with the kicker share of every deposit. each leg has a weight (all weights sum to 100%) and a mode fixed at creation:

• hold: never sold by the pot. redeem gives you your piece.
• grad: sold into the floor the moment the token graduates to its pool.
• timer: sold at graduation or when the builder's timer runs out after the first buy, whichever comes first.

a clip is that sale: clip(i, minCoreOut) sells leg i into the floor once its rule fires, and the caller gets 0.25% of what moved as bounty. the keeper clips as soon as the rule fires and sets an honest minimum out; a public clip could be sandwiched in one tx, so it is not open by default. a timer leg opens to anyone one day after its deadline, so the exit never depends on us. a grad leg without a keeper stays in the pot; redeem in kind always works. the pot never buys a leg back after a clip: the floor only ever receives.

limits: up to 6 legs of the pot's pair, no repeats, weights summing to 100%, kicker 1-50%, timer 10 minutes to 7 days, legs with a creator tax above 5% at creation refused because that tax would cut every buy. tax mode needs at least one leg. the first deposit has a dust floor of 1e12 wei.

launch and collect

launch(name, symbol, logo, description, twitter, telegram, taxBps, devBuy). anyone can launch a pons token from any pot. the pot calls the pons factory with itself as creatorFeeRecipient. the name gets the suffix by kicker, the website points at the pot's page. the pons launch fee is paid as value; the dev buy is bought by the pot inside the launch tx and handed to your wallet, the pot keeps none of the token. if the curve takes less than you sent, the remainder stays on the pot's floor. the exact ticker KICKER is reserved for the keeper.

collect() and collectRange(from, to) pull the creator tax of the tokens launched from this pot out of the pons escrow onto the floor. anyone can call it on a floor pot; it costs gas and pays every K holder. curve-phase tax lands on collect. pool-phase tax sits on the pons hook until it is swept, by the builder through sweepPool or by pons, and lands on the next collect.

moveTax(token, newPot) lets the keeper redirect a launched token's tax to another pot of the same pair from a factory in our registry. it exists for version migrations; a pot builder cannot move tax that others' launches sent to their pot.

tax buys the kicker

factory 0.4 adds a flag at creation: taxToLegs. on such a pot the collected creator tax is split like the first deposit: the kicker share set at creation buys legs by their weights, the rest lands on the floor. that is why collects move the mix. the flagship KICKX/K runs this way with $KICKER as its only leg, so every collect buys $KICKER with half of the tax and lands the other half on the gold floor.

the leg buy is bounded: on a curve the pot must receive at least 97% of the x·y=k quote after the curve's fee and tax; in a pool at least 80% of what spot implies. a buy that falls short reverts and that share stays on the floor. a leg that is clipped, dead, past its timer, a grad or timer leg that has graduated, or one whose buy reverts is skipped the same way. before the pot's first buy, collect on a tax-mode pot waits: the tax stays in escrow. while any leg can still be bought, only the builder or the keeper may call collect on a tax-mode pot, so nobody can time the buy against the pot; once no leg is buyable, collect opens to anyone. a collect that found tax and had a leg to buy also emits TaxKick(coreIn, toLegs); the floor gets the difference.

$KICKER, the coin

the floor is not the coin: pot shares redeem, the coin does not. K is a share of a pot and can always be redeemed for its part of that pot's floor. $KICKER is a pons token like any other: it has a price, a pool and no claim on any floor. a pot may hold it as a leg, the coin holds nothing.

the coin is what the platform's own share buys. the 0.5% platform slice of every buy in every pot, and 10% of every collect with launcher terms, are pushed to the KickerBuyer contract instead of a wallet. whatever arrives there (ETH or NVDA from the other floors) the keeper converts to GLD through one fixed aggregator router, and burn(minKickerOut) spends the whole GLD balance on $KICKER in its pons pool and burns what it bought out of the supply. nothing in that contract can be withdrawn by anyone: the only exit for value is the burn. the first buyer (v1) sent the coin to 0x…dEaD instead of burning it; both totals are counted together.

the platform cut is one of three ways the coin leaves the supply. the others are launch terms that send part of a coin's tax to buy $KICKER and burn it, and the floor cycle, weekly on sunday 12:00 utc: the platform wallet redeems its own K from the coin pots in kind, burns the $KICKER it gets back and puts its GLD back into the same pots the same minute. other holders' floor per K does not move and nothing is sold into the pool. the burn lists every one of them with its tx, by source.

the coin's own creator tax on pons does not go to a wallet either: a FeeRouter sends it to a pot, and the target is read live on the pots page. a launch from a pot on factory 0.6 or later can also point its burn budget at $KICKER (burn target), and the tax-mode flagship KICKX/K buys it with half of every collect.

market cap on the home page is the GLD pool price times circulating supply (1e9 minus what is burned), the same way pons reads it.

launcher terms

factories 0.5, 0.6, 0.7.2 and 0.7.3, live since 17-18.09.2026. 0.7.3 (18.09): a launch happens on pons from your wallet, the pot only receives the tax; terms use a split at a predicted address and adopt(); burns lower the token's supply. reviewed in three adversarial rounds, 44 fork tests, not yet verified on an explorer; 0.6 adds a burn target (below); the first 0.5 pot is AU/K, and every pot made on /make or /launch from now on. it adds launchWithTerms(…, taxBps, devBuy, creatorBps, burnBps). on pons a creator keeps 100% of the tax; through a pot it goes to the floor. terms are how a launcher gets paid for launching from a pot (and, on 0.6, how every launch can shrink the pot's kicker coin): creatorBps of every collect goes to the launcher's wallet, burnBps is held for a buyback of the token itself, 10% goes to the platform, the rest lands on the floor. creator plus burn is at most 80%, so the floor always keeps at least 10%. a launch with both at zero is the classic one: no platform slice, 100% to the floor. burn target (0.6): launchWithTermsTarget(…, burnTarget) points the burn budget at a leg of the pot instead of the launched token, so on KICKB/K a launcher can have part of the tax buy and burn $KICKER; if the target dies or has no market the burn falls back to the launched token.

each launch with terms gets its own TaxSplit clone as the token's creatorFeeRecipient. the terms live in that clone and nobody can change them: not the launcher, not the pot builder, not the keeper, not the factory owner. moveTax refuses a token with terms. the pot's collect() walks its launched tokens and lets each split pay out; the floor part arrives in the same transaction and is split further on a tax-mode pot.

burn(token, minTokensOut), keeper-only while the budget keeps growing; once it has sat untouched for 7 days (BURN_GRACE) anyone may burn, so a buyback never depends on the keeper. the held buyback budget leaves the split, the pot buys the token on its curve or pool and sends everything bought to 0x…dEaD. the budget never counts in the pot's nav, so a burn moves the floor by zero. the pot page shows what is waiting under launched from this pot; burnOwed(token) reads it. a token pons rescued (no market) forfeits its budget to the floor.

pins, tickers, the thread

three things on the site that are not in any contract. two are paid for by burning $KICKER, one is free and signed.

pin a pot. any open pot (not hidden, not a flagship) can sit on top of /pots for 24 h. three at a time; a pin paid while all three are taken waits its turn and still gets its full 24 h. paying again for a pin that has not ended adds 24 h. the button is on the pot's own page.

hold a ticker. a ticker held for 24 h is refused to every other wallet by the launch forms on this site: the pot page, /launch and the quick form on the home. pons itself does not know about it: anyone can still launch that ticker on pons directly. the same wallet paying again adds 24 h; a burn for a ticker another wallet already holds reserves nothing.

how the payment works. the price is fixed in GLD (0.025 GLD a pin, 0.01 GLD a ticker) and shown live in $KICKER at the price of KICKX/K's only leg, priceInCore(0). the payer's wallet sends a plain transfer(0x…dEaD, amount) on $KICKER, with 32 bytes after the arguments that say what it pays for: 'KCKR' · 0x01 · kind (0x01 pin, 0x02 ticker) · the pot address or the ticker in ascii · six zero bytes. the coin ignores the extra bytes. the site checks the tx itself: sent straight to the coin by the wallet whose tokens burned, and at least 90% of the price at that tx's own block (the site sends 3% over it). short burns for the same thing from the same wallet add up. the site looks for new ones every 30 s, so a burn counts even if the page was closed after sending. our own wallets cannot buy either feature. every such burn is on /burn under "features".

the thread. every pot page has one. a note is up to 280 characters, links show as [link], and it is signed by the wallet with personal_sign: nothing on chain, no gas. writing needs $1 of that pot held in the wallet (K × floor per K); nothing is paid. next to each note is the K its wallet held in that pot when it signed, read by the site at a block you can check. one note per pot an hour, ten a day. the author can delete a note with another signature; kicker can hide one, and the thread then says so in its place. our own wallets cannot post, except the $KICKER dev wallet.

GET https://kicker.markets/api/features
  prices, pins, held tickers, every feature burn (?ticker=BNN for one ticker)
GET https://kicker.markets/api/notes?k=0x…
  a pot's thread, 20 at a time (&before=<id> for older)
GET https://kicker.markets/api/notes?id=…
  one note with its signed message and signature

who can do what

the platform share burns $KICKER. since 17.09.2026 the platform address of every factory is a contract, KickerBuyer 0x0c596ECdf51722d46A55EB5AA48654EE7b07B44E: the 0.5% of each buy and the 10% of each collect with terms land there, in whatever floor asset the pot uses. nothing can be withdrawn from it. the keeper converts ETH and NVDA into GLD through the aggregator (convert, minimum output checked on chain) and calls burn: all GLD buys $KICKER in its pons pool and burns it out of the supply (burn() on the token; the first version, 0x587aaB8A10d9fc0dBc21A05C09F70628e2929bAC, sent it to the dead address until 18.09, and that balance stays there). burnedTotal() and spentTotal() are the running totals per version; the home page adds them up.

the keeper is the site wallet. its powers are four: redirect a launched token's tax to another pot of the same pair from a registered factory, clip legs when their rule fires, collect on tax-mode pots while a leg is buyable (both places where public timing could be gamed), and launch the ticker KICKER. it cannot touch a floor. the factory owner can add factories to the moveTax registry, rename the keeper, change the address that receives the 0.5% platform slice, and hand the owner role on; so keeper powers are owner powers one step removed. today owner, keeper and platform are the same site wallet. nothing on the factory can touch a pot's legs, fees or floor.

governance

there is none. no token votes, no timelock, no multisig, no upgrade path. the factory owner can rename the keeper, change where the 0.5% platform slice goes, add a factory to the moveTax registry and hand the owner role on; it cannot touch a floor, a leg, a weight or a fee. today owner, keeper and platform are one site wallet; when that changes it will be in the changelog. if you disagree with a pot, redeem: that is the only vote, and it always passes.

keeper:

fees

• buy: 2% of what stays invested, in the floor asset. 1% builder, 0.5% link, 0.5% platform. if a thin leg returns part of your buy, the fee is taken only on what stayed in. pots on factories 0.2 to 0.3.1 charged the full amount sent.
• redeem: no fee on the pot's side; selling legs into the floor pays pons' own trading fee and the leg's creator tax.
• clip: 0.25% of what moved, to the caller.
• collect: free, caller pays gas.
• launch: the pons launch fee, currently 0.0005 ETH, paid to pons. nothing to the site.
• the tokens: creator tax is set at launch within pons' limits; a token with more than 5% cannot become a leg of a new pot. pons takes its own trading fee on every trade; that fee and the tax are pons mechanics, the pot only receives.

what can go wrong

• legs die. most fresh tokens do. a dead leg is worth nothing; the floor is untouched. the most a buy can lose is the kicker share of the pot on the day of that buy, which drifts with the legs' price and can exceed the number set at creation.
• a leg cannot be sold. a dead curve leg comes back as tokens on either path. a pool leg whose swap reverts fails a redeem to the floor; redeem in kind always works.
• no collect, no tax on the floor. tax accrues in the pons escrow until someone presses collect. on floor pots that is anyone; we run a keeper that checks the flagships every 30 minutes and presses it once the escrow holds more than dust.
• pons. curves, pools, escrow and the launch fee are pons contracts. if pons changes, launches and collects change with it. floors and K are ours and stay redeemable.
• code. the contracts had adversarial reviews and a fork test suite; they had no external audit. read them: the current factory 0.7.3 with its implementation, the TaxSplit and the KickerBuyer are verified on sourcify (etherscan picks it up), 0.3.5 and 0.4.0 as well; the sources are public at github.com/kickermarkets/kicker-contracts.
• tokenized stocks. GLD and NVDA on robinhood chain are tokenized exposures, not brokerage shares. what they are is defined by their issuer, not by the pot.

security and reviews

what is immutable. a pot is a minimal proxy with no owner, no pause, no upgrade. legs, weights, kicker share, exit rule and tax mode are set once at creation. the only addresses a pot reads from outside are the keeper and the platform of its factory.

what was done. 44 fork tests against the live pons contracts (curves, pools, escrow) plus 3 for the platform burner, run before every deploy. adversarial reviews in september 2026 that changed the contracts: 0.3.2 added the graduation-window guard, dead-leg handling, keeper-only clip, redeem in kind on an unsellable leg and fees on what stayed in; 0.3.4 and 0.3.5 made moveTax keeper-only and reserved the ticker; 0.5 got two rounds (pull payments for the launcher's share, keeper-only burn with a public grace), 0.6 one more (a dead or stuck burn target falls back), the platform burner one. factories 0.3.5 and 0.4.0 are verified on sourcify (0.3.5 also on blockscout); 0.5.0, 0.6.0 and the platform burner are deployed from the same sources and not yet verified on an explorer.

what was not done. an external audit. the code is short; read it on etherscan, sourcify or blockscout before you deposit more than you would test with.

found something. dm @kickermarkets before posting it. a bounty is paid from the platform slice, sized by severity; there is no fixed table yet.

why the tax lands in the floor asset

most launchpads pay creator tax in the token itself, or in the pair asset to a wallet. a pot takes it in the stock pair asset (GLD, NVDA, or ETH) and keeps it on the floor. the difference for a holder:

contracts

robinhood chain, id 4663. explorer robin.etherscan.io (etherscan), also blockscout. pots are minimal proxies of the implementation of their factory. the current factory 0.7.3 and its implementation, the TaxSplit and the KickerBuyer are verified on sourcify and show on etherscan; 0.3.5 and 0.4 are verified as well. a proxy shows its source through the implementation. sources: github.com/kickermarkets/kicker-contracts

pons: factory 0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e, hook 0xE5e702641Ea86F4ae6cC3cDaeD2B886f976Be044, escrow 0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9e, uniswap v4 pool manager 0x8366a39CC670B4001A1121B8F6A443A643e40951.

events

pots on factory 0.5 emit these (older pots lack TaxKick, LaunchTerms and Burn); filter by the pot address, or by all pots of a factory through its Created(kicker, creator, core, symbol) log. topics:

• Buy(buyer, ref, coreIn, shares): a deposit.
• Redeem(owner, shares, toCore, coreOut): a withdrawal.
• Fees(creator, ref, platform, c, r, p): the 2% split of a buy.
• Clip(caller, leg, tokensSold, coreOut, bounty, graduated): a leg sold into the floor.
• Collect(caller, coreIn): creator tax moved onto the floor.
• Launched(token, curve, by, name, taxBps, devBuy): a token launched from the pot.
• TaxKick(coreIn, toLegs): on a tax-mode pot, how much of a collect bought legs.
• LaunchTerms(token, launcher, split, creatorBps, burnBps): factory 0.5, the fixed terms of a launch and the split that holds them.
• Burn(token, caller, coreIn, tokensBurned): factory 0.5, a buyback budget spent and the tokens sent to the dead address.
• Split(total, toLauncher, toPlatform, toBurn, toPot): emitted by the TaxSplit itself on every payout.

floor nav at any block is nav().navCore / totalSupply() on that block. the pot page's staircase is exactly that, read on every event block.

arc

the first pot on arc, chain 5042. a separate, smaller contract, ArcPot: the pool line of the robinhood pots without the curve and without the sleeve. its floor is USDC, the gas token of arc, read through its erc-20 view (0x3600…0000, 6 decimals; native and erc-20 are one balance). you deposit USDC and get K, an 18-decimal ERC-20 share. no legs, no clips, no kicker, no keeper, no admin: the only outside address the pot reads is the platform of its factory.

the launchpad is argus portal #7. a token launched from the pot names the pot as its creator, so the creator share of its trading tax is credited to the pot on that token's argus splitter. collect() cranks each splitter: distribute() sells what the splitter holds into USDC and credits the shares, claim(pot) pays the pot. USDC leaves the pot only by redeem, so floor nav per K, floor() / totalSupply(), only goes up.

functions

• buy(usdcIn, ref, minShares): approve USDC to the pot first. 2% comes off the top: 1.5% to the builder (1% plus the 0.5% referral slice when there is no link), 0.5% to the platform; with a link it is 1% builder, 0.5% link, 0.5% platform. self, the builder and the pot count as no link. the first buy needs at least 0.1 USDC net and burns 1,000,000 wei-shares; every later buy mints supply × net / floor.
• redeem(shares, minUsdcOut): pro-rata floor, no fee on the pot's side. redeemNoCollect(shares, minUsdcOut) is the same without the argus crank: if a splitter ever breaks the crank, the exit still works and the leaver forgoes what is pending.
• collect() and collectRange(from, to): anyone. walk the launched tokens, crank and claim, and emit what landed.
• launch(params, meta, salt, hookSalt): open to anyone since arc-0.2.1 (builder-only in arc-0.1). the name gets the suffix " by kicker" in the contract (name up to 24 bytes). tax 0.01-10% per side, at least one side above zero. creatorBps is forced to 10000, burn, dividend and liquidity to zero, quote to USDC: the whole creator allocation goes to the pot. the caller pays LAUNCH_FEE = 1 usdc plus the dev buy by approval; the fee stays on the floor, the tokens and any unspent dev buy go to the caller, the pot keeps none. hookSalt is mined by the caller so the hook address carries the flags argus requires (predictHook on the portal says if it is valid). at most MAX_LAUNCHES = 16 per pot, then launch reverts "full" and the builder opens the next pot from the factory. the cap is what lets every buy and redeem crank all launches: pending tax is realised before any mint or burn, so it can never be skimmed by a buyer who enters just before a collect.
• skim(token): stray tokens (airdrops, mistakes) go to the builder. USDC and the pot's own launched tokens never leave this way.
• reads: floor(), collectable() (what the splitters have already credited, before the crank), launchedCount(), launched(i), isLaunched(token), creator(), factory().

the crank

every buy and every redeem runs collect() over all launched tokens first. a buy cranks so that pending tax accrues to the holders who were in before it, not to the new shares; a redeem cranks so the leaver takes its share of what is pending too. the caller pays that gas, which is why the launched list is capped at 16. each splitter call is a low-level call with a gas cap, 600,000 for distribute() and 150,000 for claim(): a splitter that reverts or burns its gas is skipped and cannot take the caller's gas with it, and a failure there never blocks the exit.

addresses

arc, chain 5042. explorer arc.etherscan.io. pots are minimal proxies of the factory's implementation.

events

filter by the pot address, or by all pots of the factory through its Created(pot, creator, symbol) log. the signatures differ from the robinhood pots: Redeem has no toCore, Launched has no curve and carries both tax sides. topics:

floor nav at any block is floor() / totalSupply() on that block; shares are 18-decimal, the floor is 6-decimal. reads go through /api/arc, a read-only json-rpc proxy, or the public rpc https://rpc.mainnet.arc.io.

what can go wrong

• no audit. the contract is immutable and has no admin: nothing can be paused, fixed or upgraded. if a bug freezes it, deposits are frozen. deployed 16.09.2026 on arc mainnet, redeployed 17.09 after the third adversarial review; every set of findings fixed; version arc-0.2.1.
• the crank. every buy and redeem also cranks argus for every token launched from the pot, and you pay that gas. the crank is gas-capped per token and there is a redeemNoCollect that skips it, so an argus failure cannot lock your exit; if redeem ever fails on the page, it offers that, and the pot is callable directly on arcscan.
• usdc. usdc is the gas token and subject to circle's blocklist: a blocklisted pot or builder address can block redeems or buys.
• an empty pot. if everyone leaves, tax collected while the pot is empty is burned to the dead address, not paid to anyone.
• stray assets. any stray non-usdc asset the pot receives goes to the builder; usdc and the pot's own launched tokens never leave that way.
• credited, not on the floor yet. what argus's fee splitter has already credited to the pot; tax still sitting in the splitter appears on the floor after the next buy, redeem or collect.
• open launch. anyone can launch from the pot (arc-0.2.1); the floor grows only when the launched tokens are traded, and every launch leaves 1 usdc on it.

not verified on an explorer yet, no audit, three adversarial reviews on 16-17.09 (the third moved launch to anyone, bounded the pot at 16 launches and added the launch fee). treat it as experimental; the source is contracts/src/arc/ArcPot.sol and it is short.

api

the site's reads are public and cached for 15 seconds. no keys.

GET https://kicker.markets/api/kickers
  every pot: nav, supply, legs, launches, last buys / clips / collects / redeems,
  income (tax that landed: d7, d30, all) and incomeUsd (each collect at its day's price),
  yield7 (7-day tax / the floor averaged over those 7 days, weekly; null under 3 collects
  or $100 of average floor), collectDays (14 days, usd), lastCollect, tradedUsd, leaderboard
GET https://kicker.markets/api/kickers?k=0x…
  one pot, plus series: floor per K on the last 120 event blocks, and a longer tail of events
GET https://kicker.markets/api/kickers?me=0x…
  adds that wallet's own buys, redeems, collects, clips and burns per pot, its K balance (myK)
  with ?mine: taxEarned per pot, that wallet's share of every collect when it landed
  (Σ collect × its K / supply just before), in the pot's asset and at the day's price
  and a me summary: badges (holder since, builder of N pots, launched N coins, launched with
  terms, burned $KICKER, first buyer of a pot, flagship holder), what it holds in dollars
GET https://kicker.markets/api/pons?tokens=0x…,0x…   logos
GET https://kicker.markets/api/pons?caps=0x…,0x…     market caps of graduated tokens

the api is a convenience; the chain fields can be recomputed from the events above and the pons contracts. tradedUsd sums every curve and pons-pool trade of tokens launched from pots, each at its day's price; holders are counted from buys and redeems only.

agents

for llm agents there is skill.md: addresses, function signatures with argument meanings, read endpoints, rules and safety notes, in the shape agent skill files usually take; and llms.txt with the links. an agent can read pots, compute floor nav and prepare calldata; signing stays in the user's wallet on chain 4663.

glossary