ringmakers is a program attached to one coin. The coin was launched on pump.fun, and pump.fun pays a creator fee on every trade. That fee goes to an account owned by the program, and the program uses it to run market makers on the coin.
The makers sit in rings of eight seats. Each seat holds a balance that is sealed inside Helius Privacy Rings, so the amount exists on chain as a commitment and not as a number. A seat's quotes are public. Its remaining balance is not.
Nothing in the system runs on a clock. Trades cause strikes, strikes cause fills and lifts, lifts cause passes, and passes cause laps. If nobody trades, nothing happens.
ringmakers never holds your tokens. There is nothing to deposit and nothing to claim. The makers trade against the same pool everyone else does.
The only money in the system is the coin's creator fee. Nothing is minted to fund the makers and nobody tops the vault up. If the coin does no volume the vault receives nothing, no rings are forged, and that is the correct result.
The fee is routed with pump.fun's own fee sharing config. The config names one recipient, the ringmakers vault, at the full share, and the right to change it is revoked when it is set. From then on, paying the vault is a public instruction that anyone can call. On this site that instruction shows up as a harvest.
After the coin leaves the bonding curve and trades on the pump AMM the same route applies.
Fee arrives in the vault as ordinary SOL and is counted as unassigned. It stays that way until there is enough to forge a ring. At a forge the cost of the ring moves from the vault into a private escrow inside Helius Privacy Rings in one transaction.
The amount that goes in is public, because it leaves a public account. What Rings add is that the escrow can then be divided into separate balances whose sizes are hidden behind commitments, and the program can check proofs about those balances without learning them.
There are six ring positions, numbered from the inside out. Position k quotes at a width of 0.50 percent times two to the k and trades a clip of 0.02 SOL times two to the k. The inner ring answers small moves with small size. The outer ring ignores everything under sixteen percent and answers with thirty two times the size.
A position is empty until a ring is forged into it. A ring is forming while its seats are being committed, live while any seat can still trade, and closed once all eight are spent. A closed position can be forged again, and the new ring is the next generation of that position.
A seat is a program account with no key. It records a commitment to its sealed SOL balance, a reference price, a bid, and after a fill the tokens it holds, what it paid, and an ask. It also counts its fills, lifts and passes in the open.
A seat is always in one of five states. Quoting means it has a bid in the market. Holding means it has bought a clip and is waiting for its ask. Crossed means price went through its bid and no fill was proven. Spent means it was retired. Opened means its balances have been published.
Forging is public. When the vault's unassigned fee covers the cost of the lowest empty position, any wallet can call forge. The cost is 48 clips of that position, so 0.96 SOL for the inner ring and twice as much for each ring out.
The wallet that forges posts a bond of five percent of the cost from its own funds, chooses how the cost is divided among the eight seats, and submits one commitment per seat with a proof that every seat holds at least two clips and that the eight amounts add up to exactly the cost. The program checks the proof and never sees the amounts.
cost(k) = 48 × clip(k) bond(k) = 0.05 × cost(k) proof : each seat ≥ 2 × clip(k) and sum of seats = cost(k)
The wallet that forged a ring is its ringmaker. It is the only party that knows the split, so it is the only party that can produce the proofs a seat needs in order to fill. That is its whole job.
A ringmaker cannot withdraw from a seat, change a quote, pick a price or choose which seat trades. The program fixes all of that. It can only supply proofs, and if it does not, its seats are retired and its bond is burned.
It is paid two percent of every gain its ring makes, and the pay is released only when the ring completes a lap. A ring that stalls halfway around pays its ringmaker nothing.
A seat's bid is its reference price less the ring's width. The reference is the pool price at the moment the ring was forged, and after that the pool price at the seat's most recent lift. Prices are read straight from the pool's reserve accounts. There is no oracle.
Once a seat has bought, its ask is its entry price plus the ring's width. A seat has one bid or one ask at a time, never both.
bid = reference × (1 − width) ask = entry × (1 + width)
A strike is a public instruction that reads the pool price and records it. When a strike finds the price at or below a quoting seat's bid, that seat can be filled. The fill instruction carries a proof that the seat's sealed balance is at least one clip. If it verifies, exactly one clip is unsealed, spent on the pool, and the tokens are held in the seat's public token account.
The proof says nothing about how many more clips the seat has. A seat with one clip left and a seat with forty look the same when they fill.
When a strike finds the price at or above a holding seat's ask, anyone can call lift. No proof is needed, because the tokens are public. The seat sells the clip's tokens to the pool. The clip it spent is sealed back into its balance, and the gain above that is split.
After a lift the seat's reference becomes the current pool price and it is quoting again.
The gain from a lift is divided four ways in the same instruction. Fifty percent is sealed back into the seat that earned it. Twenty eight percent is sent as a private transfer to the next seat around the ring, seat seven passing to seat zero. Twenty percent leaves the ring for the burn. Two percent is held for the ringmaker.
gain = proceeds − clip stays = 0.50 × gain passed = 0.28 × gain to seat (s + 1) mod 8 burned = 0.20 × gain held = 0.02 × gain for the ringmaker, released on a lap
The pass means a seat that trades well keeps its neighbour alive. Balance moves around the ring in one direction only.
Each ring keeps eight bits, one per seat. A seat's bit is set the first time it passes. When all eight are set the gain has travelled the whole ring. That is a lap. The lap counter goes up by one, the bits clear, and the ringmaker's held pay for that lap is released.
Laps are the system's only measure of progress, and they cannot be scheduled. An inner ring in a choppy market can turn several in an hour. An outer ring may never turn one.
If a strike finds a seat's bid crossed and no fill is proven, the seat is marked crossed and a counter goes up. A later fill clears it. After sixteen crossed strikes in a row, anyone can retire the seat. A retired seat is spent and never trades again.
The count is of strikes, which are price reads caused by trades. It is not a count of seconds, blocks or slots.
A spent seat still hides its history. To release that seat's eighth of the bond the ringmaker must open it by publishing the amount the seat was forged with and the amount it ended with, along with the values that tie them to the seat's commitments. The program checks them and writes both amounts into the seat's account in the clear.
An opened seat's residue, which is always less than one clip, returns to the vault as unassigned fee.
Opening can show one of two things. If the seat ended with less than a clip it was retired honestly and that part of the bond is returned. If it ended with a clip or more, the seat could have filled and the ringmaker let it die. That part of the bond is slashed and spent on the burn.
A seat that is never opened keeps its part of the bond locked for good. Either way the ringmaker does not get it.
When all eight seats of a ring are spent the ring is closed. Whatever SOL it still holds returns to the vault as unassigned fee, any tokens still held by its seats are burned, and the position becomes empty. The next forge into that position starts a new generation.
Twenty percent of every gain and every slashed bond is spent buying the coin from the pool, and the tokens bought are burned in the same instruction. The burn has no schedule and no minimum. It happens at each lift and each slash, in the size that event produced.
Public: every fee harvested, the cost of every ring, every clip bought and sold, every seat's quotes, tokens held, counts and state, every gain and how it was divided, every lap.
Sealed: how a ring's total is divided among its seats at any moment before those seats are opened.
That one hidden thing is enough. Nobody can tell which seat is about to run dry, so nobody can lean on a maker's last clip. And because every amount crossing the ring's edge is public, the ring's total can always be checked by addition.
The program keeps four kinds of account. All integers are little endian and every account starts with an eight byte discriminator. Prices are stored as lamports per base unit of the coin, scaled by two to the 64.
| offset | size | field |
|---|---|---|
| 0 | 8 | discriminator |
| 8 | 32 | mint |
| 40 | 8 | harvested_lamports |
| 48 | 8 | unassigned_lamports |
| 56 | 8 | sealed_lamports |
| 64 | 8 | burned_tokens |
| 72 | 8 | burn_spent_lamports |
| 80 | 8 | ringmaker_paid_lamports |
| 88 | 8 | strikes |
| 96 | 8 | fills |
| 104 | 8 | lifts |
| 112 | 8 | passes |
| 120 | 8 | laps |
| 128 | 4 | rings_forged |
| 132 | 4 | rings_closed |
| 136 | 4 | seats_opened |
| 140 | 1 | live_mask (bit k set when ring index k is live) |
| 141 | 1 | bump |
| 142 | 16 | last_price_q64 |
| 158 | 8 | last_strike_slot |
| 166 | 16 | ath_price_q64 |
| 182 | 8 | slashed_lamports |
| offset | size | field |
|---|---|---|
| 0 | 8 | discriminator |
| 8 | 32 | mint |
| 40 | 1 | index (0 inner to 5 outer) |
| 41 | 1 | state (0 forming, 1 live, 2 closed) |
| 42 | 4 | generation |
| 46 | 32 | ringmaker |
| 78 | 8 | bond_lamports |
| 86 | 8 | forged_lamports |
| 94 | 8 | total_lamports |
| 102 | 8 | clip_lamports |
| 110 | 2 | width_bps |
| 112 | 1 | lap_mask (bit s set when seat s has passed this lap) |
| 113 | 1 | spent_mask |
| 114 | 4 | laps |
| 118 | 4 | fills |
| 122 | 4 | lifts |
| 126 | 4 | passes |
| 130 | 8 | profit_lamports |
| 138 | 8 | burned_lamports |
| 146 | 8 | ringmaker_accrued |
| 154 | 8 | forged_slot |
| 162 | 8 | closed_slot |
| 170 | 1 | bump |
| offset | size | field |
|---|---|---|
| 0 | 8 | discriminator |
| 8 | 32 | ring (address of the ring account) |
| 40 | 1 | seat (0 to 7) |
| 41 | 1 | state (0 quoting, 1 holding, 2 crossed, 3 spent, 4 opened) |
| 42 | 32 | commitment |
| 74 | 16 | ref_price_q64 |
| 90 | 16 | bid_price_q64 |
| 106 | 16 | ask_price_q64 |
| 122 | 8 | held_tokens |
| 130 | 8 | entry_lamports |
| 138 | 4 | fills |
| 142 | 4 | lifts |
| 146 | 4 | passes_out |
| 150 | 4 | passes_in |
| 154 | 2 | crossed_strikes |
| 156 | 8 | profit_lamports |
| 164 | 8 | last_slot |
| 172 | 8 | opened_lamports (forged balance, zero until opened) |
| 180 | 8 | opened_final_lamports |
| 188 | 1 | bump |
| offset | size | field |
|---|---|---|
| 0 | 8 | discriminator |
| 8 | 32 | mint |
| 40 | 2 | head (next write index, 0 to 63) |
| 42 | 8 | count (events ever written) |
| 50 | 1792 | 64 entries of 28 bytes: 0 kind u8, 1 ring u8, 2 seat u8, 3 flags u8, 4 lamports u64, 12 tokens u64, 20 slot u64 |
Every instruction is public. None takes an authority.
| instruction | called by | needs a proof | what it does |
|---|---|---|---|
| harvest | anyone | no | moves the coin's creator fee into the vault as unassigned |
| strike | anyone | no | reads the pool price, records it, marks crossed seats |
| forge | anyone | yes | posts the bond, seals the cost, commits eight seat balances |
| fill | ringmaker | yes | unseals one clip from a crossed or quoting seat and buys |
| lift | anyone | no | sells a holding seat's clip, reseals, splits the gain |
| retire | anyone | no | marks a seat spent after 16 crossed strikes |
| open | ringmaker | yes | publishes a spent seat's balances, settles its bond share |
| close | anyone | no | closes a ring whose eight seats are spent |
These are fixed in the program and cannot be changed.
| constant | value |
|---|---|
| seats per ring | 8 |
| ring positions | 6 |
| inner width | 0.50% |
| inner clip | 0.02 SOL |
| doubling per ring | 2× |
| forge cost | 48 clips |
| minimum per seat | 2 clips |
| bond | 5% of forge cost |
| gain to seat | 50% |
| gain passed | 28% |
| gain burned | 20% |
| gain to ringmaker | 2%, released on a lap |
| strikes to retire | 16 |
| events kept on the tape | 64 |
Fees harvested is every lamport the vault has ever received. Unassigned is the part still waiting to be forged. Sealed in rings is the sum of every live ring's total.
A commitment is shown by its first eight characters. It changes every time the seat's balance changes, so two rows with the same count of fills will still show different commitments.
Bid and ask distances are measured from the last price the program recorded, so they move with every strike. The quote levels on the rings page are measured from the live value instead, which is why the two can differ by a tick.
Value is price times supply, read once a second. It is the only figure on the site that does not come from the program.