The Tallystick whitepaper.
Every rule set down: parameters, the exact mechanism, worked examples, edge cases, plus the reads that prove each claim on-chain.
1 · Abstract
Tallystick is an Ethereum-network token. 900,000 TALL exist, all of them in the market from launch and none ever created after. The pool is Uniswap v4; trades price in ETH; each one pays a 2% Paring and cuts a Notch — an obligation on the record, carrying that trade’s size and block — onto the Scoreline, an append-only queue. A Tallage, callable by anyone, spends the gathered Paring retiring TALL from the market, marking the queue in opening order with no exceptions. Retired TALL is Char: permanent. Supply, then, moves only downward, and the three rules governing it — the fee, the order, the supply — carry no setter.
2 · The problem, stated once
Fee-taking tokens usually make two quiet promises: that the fee will be used as described, and that the queue of things owed will be honoured in turn. Both promises live off-chain, in a description somewhere, and both can be broken without leaving a visible trace.
Tallystick moves both on-chain: the fee’s use is the only thing the fee can do, and the queue’s order is the only order the contract can work. What other systems promise, this one makes unavailable for breaking.
3 · Design
Two contracts, with a clean split of authority. The token keeps balances and the supply; it can retire units and report the retired total, and nothing else. The queue contract is attached to the market; it takes the Paring from every swap, keeps the Scoreline, and answers Tallages.
The token cannot open a Notch and cannot take a fee. The queue contract cannot touch a balance and cannot create a unit. Neither contract exposes a function that changes the Paring, shuffles the Scoreline, or returns Char to supply.
4 · Parameters
| Parameter | Value | Units | Kept | Setter |
|---|---|---|---|---|
| Token name | Tallystick | text | token contract, constant | none |
| Symbol | TALL | ticker | token contract, constant | none |
| Decimals | 18 | places | token contract, constant | none |
| Supply at launch | 900,000 | TALL | token contract, fixed at deployment | none |
| The Paring | 2 | % of each trade | queue contract, fixed at deployment | none |
| The working order | Oldest open Notch first | rule | queue contract, append-only | none |
| Market | Uniswap v4 | venue | the pool, recognised on first trade | not ours to set |
| Chain | Ethereum | network | the chain itself | not ours to set |
| Quoted in | ETH | asset | the pool pair | not ours to set |
Each value on this table is the value the contract holds. A reader who finds a mismatch between this table and the chain has found a defect in this document, not a parameter.
5 · Mechanism
A trade. When a swap touches the market, the queue contract takes the Paring — 2% of the traded amount, buy or sell alike — and holds it. It then opens a Notch: that trade’s TALL size, an open amount of 2% of that size, the current block, and the next ordinal. It emits paring and notched.
A Tallage. Anyone calls it. The queue contract sums the open amounts of the oldest live Notches, spends the gathered Paring on TALL from the market; the token then retires what was bought. It then marks the queue from the oldest end: a Notch whose open amount is covered is discharged and removed; the first Notch only partly covered stays open with its remainder reduced. It emits tallied, and the token emits char. A Tallage can never retire more than the queue stands owed, and can never work a younger Notch before an older one.
The record. A rolling hash chains each event to the one before it, and scoreline() exposes the current link. The history of the queue is therefore tamper-evident as well as public.
6 · Worked examples
A busy stretch
Trades of 10,000, 4,000 and 6,000 TALL arrive in that order. The Scoreline stands: №1 open 200, №2 open 80, №3 open 120. A Tallage retires 250 TALL: №1 is discharged in full, №2 drops to a remainder of 30, №3 stands untouched. The next Tallage begins at №2.
A quiet stretch
No trades arrive. Nothing gathers, nothing opens, nothing is marked. A Tallage called with nothing gathered reverts without touching the queue. Open Notches stand waiting.
7 · Failure and edge cases
| Case | What happens |
|---|---|
| No trades for a stretch | Nothing moves. No Paring gathers, no Notch opens, no mark advances. |
| A Tallage with nothing gathered | The call reverts. Queue state is unchanged; no event is emitted. |
| A Tallage smaller than the oldest Notch | The oldest Notch remains open, its remainder reduced by exactly what was retired. |
| A reverted trade | It never happened: no Paring, no Notch. |
| The queue empties | The Scoreline stands with no open units until the next trade. Parings from later trades gather for later Notches. |
8 · Fixed forever
The Paring is 2%, the Scoreline is worked in opening order; the supply began at 900,000 TALL and only shrinks. None of the three carries a setter, so no account — the deployer’s included — can change any of them. The deployer also cannot touch a holder’s balance, suspend trading, or reissue Char. Its authority ended at deployment.
9 · Verification
Read scoreline() for the queue and the waiting parings, cuttings(n) for any single Notch, and charred() with totalSupply() for the retired total — the two always sum to the launch figure of 900,000. The event log prints the order: paring on each trade, notched on each Notch, tallied on each discharge, char on each retirement. Nothing in this paper asks for trust in anything but those reads.
10 · Notation and definitions
| Term | Definition |
|---|---|
| The Paring | The 2% a trade leaves with the mechanism; the only charge. |
| A Notch | The obligation one trade opens: its TALL size and its opening block. |
| The Scoreline | The append-only run of open Notches, worked from its oldest live index. |
| A Tallage | The permissionless discharge: retires TALL with the gathered Paring, in opening order. |
| Char | TALL retired by a Tallage; permanently out of supply. |
| The Standing Rules | The Paring, the opening order, the supply — the rules written without setters. |