Plug a coin's fees into four jacks.

01What is Jackfiled

Every Pons V2 coin has exactly one fee seat: the creatorFeeRecipient. Whoever sits in it collects the coin's creator tax (0 to 10% per trade, chosen at launch) plus 70% of Pons' 1% base fee. By default that is the dev's own wallet, and nothing stops them from keeping all of it.

Jackfiled moves that seat into a public contract called a Jack, one per coin. The Jack pulls the fees from Pons and splits every wei into four buckets you can see on-chain: BURN, HOLDERS, FUND and CREATOR.

• Not a launchpad. Coins keep trading on Pons exactly as before. Jackfiled only changes where the creator's share goes.
• Works for old and new coins. Existing coins patch in with three transactions; new coins reserve a Jack before launch.
• Raise-only. Burn and holder shares can go up later, never down.
• No custody. Nobody, including us, can withdraw from the BURN or HOLDERS buckets except by burning or by holder claims.

02Check a coin

Open App → Check and paste any Pons coin address. Jackfiled reads the Pons V2 factory and prints a fee receipt:

The verdict is colour-coded:

• Dev wallet fees land in a private wallet. Nothing is promised.
• Unknown contract a contract holds the seat. It may be fine (a treasury, a splitter) or not; read its code.
• Patched the seat is a Jack. The receipt shows its split in the four jack colours.

The check works even when the Jackfiled indexer is down: the page falls back to reading Robinhood Chain directly.

03Patch your coin

Only the wallet that currently holds the coin's fee seat can patch it. Pick a split in App → Patch; the page previews where 1 ETH of fees would go.

Existing coin (three transactions)

1. Deploy the jack. JackfiledFactory.patch(token, split, fund). The factory checks that you hold the seat and deploys the coin's Jack at a fixed address.
2. Plug the fees in. PonsV2LaunchFactory.transferCreatorFeeRecipient(token, jack). This is a Pons call: it moves the fee seat to the Jack.
3. Switch it on. Jack.bind(token). Anyone may call it for a patched coin, and the first harvest does it automatically.

New launch (reserve → launch → bind)

1. Reserve a jack. JackfiledFactory.reserve(split, fund, salt). The address is known in advance (CREATE2), so it can be shown before you sign.
2. Launch on Pons with that jack address as the Creator fee recipient, a native ETH pair, and buyback off (so the jack can sweep the curve itself).
3. Bind. Jack.bind(token) from the creator wallet. Only the creator may bind a reserved jack, so nobody can attach a junk coin to it.

Jackfiled only plugs coins that trade against native ETH. One coin has one jack, forever, and a Jack never gives the Pons seat away.

04The four jacks

A split is three numbers in basis points (1% = 100 bps): burnBps, holdersBps, fundBps. CREATOR is whatever is left: 10000 − burn − holders − fund.

If a push to the fund or creator fails (for example a contract that rejects ETH), the amount is kept for that address and can be pulled any time with withdraw().

05Raise-only rules

The split is a commitment. After a jack is live:

• raiseBurn(newBps) and raiseHolders(newBps) can only increase those shares. The extra comes out of the creator share.
• There is no function to lower BURN or HOLDERS, and FUND cannot be changed in size at all.
• ETH already in the jack when a raise happens is split under the old terms first.
• No owner can withdraw from the BURN or HOLDERS buckets. The factory owner can only rotate the keeper and the root poster.

06Holder rounds

The HOLDERS bucket is paid out in rounds, at most about once a day per coin and only when at least 0.001 ETH is waiting.

1. Time-weighted balances. The Jackfiled indexer replays the coin's Transfer events and accumulates balance × time for every holder since the last round. Buying right before a round earns almost nothing; holding through it earns a full share.
2. Exclusions. The jack itself, 0x…dEaD, the zero address, the token, its Pons curve, the Pons factory / escrow / hook / buyback vault, the Uniswap V4 PoolManager, the Jackfiled factory and every contract address are excluded, so pools and bots-in-contracts do not dilute real holders.
3. Merkle root. Each holder's amount goes into an OpenZeppelin StandardMerkleTree with leaf keccak256(bytes.concat(keccak256(abi.encode(round, holder, amount)))). The root poster calls postRoot(root, total), which moves total from the HOLDERS bucket into the round.
4. Claim. In App → Claim each open round shows a button: claim(round, amount, proof) sends the ETH to your wallet.
5. Expiry. After 180 days anyone may call expireRound(round); the unclaimed rest returns to the HOLDERS bucket for future rounds. Nothing is lost to the team.

Roots and the raw per-holder amounts are published by the indexer so anyone can rebuild and verify the tree.

07Harvest & burn

harvest() is permissionless: anyone can press it on the board, and the Jackfiled keeper calls it about every 10 minutes. Each step is best-effort, so one failure never blocks the rest:

After graduation, Pons fees in the V4 hook usually need the Pons operator to sweep (they convert memecoin-denominated fees to ETH first). The operator's sweeps credit the escrow, and the next harvest claims them.

Burn

executeBurn(minOut) spends the whole BURN bucket. Only the keeper or the creator may call it, because it needs a sensible minOut (the minimum coins to receive) to avoid being sandwiched. On the curve it buys with curve.buy; after graduation it swaps ETH → coin in the Pons V4 pool and reverts if it gets less than minOut. Every bought coin goes to 0x…dEaD.

08Handover

Seats move in two steps, so a typo can never send them to a dead address:

• Fund seat: the creator calls proposeFund(next); the new address calls acceptFund().
• Creator seat: the creator calls proposeCreator(next); the successor calls acceptCreator(). A dev who wants to step away can hand the coin to a multisig or a community wallet this way.
• Proposing the zero address cancels a pending proposal. ETH already owed to the old address stays withdrawable by it.

Both actions are on the coin's jack page (/jack/?t=<token>) for the connected creator, and the accept button appears for the proposed wallet.

09Contracts & addresses

Robinhood Chain mainnet, chain id 4663. Read live from contracts.json.

The Jackfiled factory deploys at launch. Until then the app runs in preview mode: Check and the unpatched list work from Pons, and the patch buttons say "Jackfiled deploys at launch". Contracts are not externally audited.

10Risks

• Root poster trust. Holder rounds are computed off-chain by the Jackfiled indexer and posted by the root poster. A wrong root could misallocate a round (never more than the HOLDERS bucket). Roots and raw data are published for verification; the factory owner can rotate the poster.
• Burn slippage. Burns buy on the open market. Thin liquidity means fewer coins per ETH, and a bad minOut could be front-run. Only the keeper or creator can burn, with a quoted minimum.
• Graduated sweeps. After graduation, fees depend on the Pons operator sweeping the V4 hook. Delays are possible.
• Smart-contract risk. The contracts are tested against a fork of mainnet Pons but not externally audited. Bugs are possible.
• Commitment is not a promise of price. Burns and holder payouts depend on trading volume. No volume, no fees.
• Not financial advice. Nothing on this site is financial advice. Do your own research.

11$JACK token

$JACK launches on Pons and is plugged into Jackfiled from day one, through its own jack. Planned split:

$JACK is a community token with no promise of return. The only official contract address is the one shown on this site and pinned on our X and Telegram.

12FAQ