TimbSwap Litepaper

Abstract

TimbSwap is a decentralized exchange with a prize game built into it — and one incentive engine underneath both. Swap fees and yield on capital held in the protocol fund a recurring, on-chain prize; the same flow replenishes staking and farming rewards. The swap, the staking, the farming, and the game are not separate products but modules of a single self-funding loop. What the protocol earns is swept back to the people who generate it, on a fixed cadence, under hard solvency limits — rewards are funded by real inflow, never printed. Every step is executed by open-source, permissionless, non-custodial smart contracts. The closest traditional analogue is a prize-linked savings account (Premium Bonds, Save-to-Win): prizes come from yield, not from anyone's principal.

1The problem

Most DeFi rents activity rather than earning it. Three patterns recur:

• Printed rewards. Emissions dilute holders to buy short-term usage; when they taper, mercenary capital leaves and volume collapses.
• Static incentives. Reward rates are fixed and disconnected from whether the protocol is actually healthy.
• Fragmented pieces. AMMs reward liquidity but not engagement; staking rewards holding but is often pure inflation; prize dapps drive attention but are detached from real yield. Nobody ties them into one self-funding loop.

The model TimbSwap uses — prizes funded by yield on pooled capital — is proven at enormous scale off-chain: prize-linked savings (UK Premium Bonds, US Save-to-Win), and loyalty programs whose reward layer grew worth more than the business that ran it. No crypto-native project has captured a comparable share of its own space. That gap is the opening.

2The incentive engine

One inflow drives every module. Value moves in one direction, on a fixed cadence:

• Trade. Every swap pays a 0.3% fee — 0.25% to liquidity providers, 0.05% to the treasury. Eligible swaps also advance the prize meter.
• Collect. The treasury pools fee inflow and buybacks; ticket deposits sit in the TimbYieldVault, whose accrual grows the prize pot. All backing is visible on-chain.
• Reward. Every six rounds an autonomous keeper sweeps what was collected and refills the reward pools in fixed priority — pot → farm → staking → boost.
• Return. Winners claim, stakers and farmers compound, players re-enter — feeding step one again.

Because prizes and emissions are paid from what the protocol has actually earned, the opportunity persists even on low-volume or low-volatility days: the edge is generated by the protocol's clock, not discovered in the market.

3The prize game

Each round is a six-character combination that assembles live. Players hold a ticket — a 6-character string (A–Z, 0–9, no repeats) that plays the next round.

• Six segments, one hour each. A round has 6 segments (≈60 min: open window + a short settlement). Every eligible swap nudges the active segment's character upward on a continuous meter.
• Locking & jitter. When a segment closes, its character locks — the nudge counter jittered with the settling block's hash, and randomized within its class (a letter stays a letter, a digit stays a digit). You can aim the class per position, but the exact character stays unpredictable.
• Permissionless settlement. Segments settle permissionlessly once the window elapses — anyone can call settleSegment. No operator gates the round.
• Winning & claiming. After all six lock, an exact match wins the pot. Winners claim within 2 rounds of the match; a lapsed prize recycles into the pot.
• Principal is yours. A ticket's deposit stays refundable for 4 rounds after its last eligible round (extended, never shortened, if you win near the end), and while active it earns yield that grows the pot.
• Generations. The registry is keyed by a game generation; a redeploy bumps the generation and makes prior tickets inert, their principal recoverable at any time — a clean reset without a fresh registry.

4Tokenomics & emissions

• Fixed supply. TIMBS is hard-capped at 100,000,000, with no mint beyond the cap — a fixed schedule finalized at mainnet launch.
• Fee split. Each swap's 0.3% fee splits 0.25% to LPs and 0.05% to the treasury, which funds buybacks (50% burned, 50% to stakers) and the reward cycle.
• The epoch waterfall. Every 6 rounds the keeper measures what was actually claimed from farm and staking and what the treasury collected, then refills in priority: farm first (≤80% of its claims), staking next (≤1.25× its claims, capped at 80% of the remainder), and boosted farms receive only what's left. If inflow runs short, the tail goes unfunded — nothing is printed to cover it.
• Solvency stop. Reward contracts track every wallet's accrued-but-unclaimed balance as an explicit liability. When obligations reach 99% of reserves, accrual halts until the next refill. The system cannot promise tokens it does not hold.
• Self-retargeting rates. Emission rates recompute from free (unowed) reserves over the emission window, so a shrinking reserve slows emissions instead of over-committing.

5Architecture & trust

TimbSwap is open-source, decentralized, permissionless, and non-custodial — a set of EVM-native Solidity smart contracts (0.8.24, viaIR), verified on Sourcify. The contract layout mirrors the engine:

• AMM core — Factory, Router, and Pairs generate fees (a Uniswap-V2-style constant-product exchange).
• Game layer — TimbPrize, GameRegistry, TimbYieldVault, and PrizeEscrow run rounds and hold the pot's backing.
• Emissions layer — Staking, Farm, BoostFarm, and Treasury distribute rewards under the solvency rules above.

The frontend is a static site — every figure is read live from chain, users hold their own keys, and an autonomous GitHub Actions keeper settles segments and runs the reward sweep without a human in the loop. Contract addresses are published in the Docs address table and the open-source repository — verify before you trust any label.

6Risks

• Smart-contract risk. The contracts are testnet-hardened but unaudited; an independent audit gates mainnet. Permissionless refund and recovery paths exist so funds are never trapped behind an operator.
• Impermanent loss. Providing liquidity carries standard AMM IL, larger on thin or volatile pairs (boosted farms are the highest-risk seat).
• Game randomness. Locked characters are jittered with the settling block's hash — you aim a class, not an exact character. Treat the game as chance-weighted, not skill-guaranteed.
• Emissions variance. Reward rates move with the waterfall and total staked; a testnet APR is illustrative, not a promise of yield.
• Regulatory. Prize mechanics are classified differently by jurisdiction. On testnet nothing has value; before any real-value launch, formal counsel and likely geofencing are gating conditions.
• Testnet impermanence. Test networks can be reset or halted at any time; assume all testnet state is disposable.

7Roadmap & the graduation gate

Now · live — The full engine runs end-to-end on Arbitrum Sepolia: AMM, prize game with permissionless settlement and generations, emissions on the epoch waterfall with the 99% solvency stop, and an unattended keeper.

Next — The road to mainnet, gated on evidence and safety: proven engagement (sustained wallets, repeat play, eligible volume tracking rounds); an independent audit and security policy; legal counsel and likely geofencing; seeded liquidity and an initial pot; and live signal dashboards from existing telemetry.

Vision — Adaptive incentives: the allocation cycle is rule-based and solvency-bounded today; the same telemetry that proves solvency is the substrate for a future policy that tunes incentives to observed protocol health — still on-chain, still bounded by the identical guardrails. Stated as direction, not a capability claimed today.

References

• Documentation — user guide, mechanics, and the verified contract address table.
• GitHub repository ↗︎ — open-source contracts and frontend.
• ROADMAP.md ↗︎ · SPECS.md ↗︎ — roadmap and full technical specification.
• Sourcify (chain 421614) ↗︎ — contract verification.

Litepaper v0.1 — a living document; figures and mechanisms track the deployed contracts and may evolve before mainnet.