# Audit report > moneycanbuy.fun: audit the tokenomics and utility of its token $YOLO before mainnet launch. Foundry project is contracts/: run forge from there, import as "src/...". Source of truth: docs/TOKENOMICS.md and docs/TOKEN-UTILITY.md. docs/MECHANICS.md and contracts/src/ are an earlier version (see its banner); a disagreement with the two files above is not a finding to repeat — note it once as the single COVERAGE entry at the end. Use the contracts only where they overlap the current docs (escrow, bond-and-dispute flow, balance accounting); do not fault code for lacking a mechanic only docs/TOKEN-UTILITY.md describes. Do not modify, delete or reformat any file; findings go only into the report and NEW test files under contracts/test/scratch/. > > MODEL docs/TOKENOMICS.md AND docs/TOKEN-UTILITY.md DESCRIBE (exact numbers there, not here): fixed 1,000,000,000 YOLO, no owner, no mint, no pause. No reward limit of any kind: no per-task cap, no total-open cap, no top-up cap, no Predict per-address cap. Each currency has its own fixed minimum reward (5 USDC, 0.002 ETH, 1 IMD, 1,000 YOLO), needing no price. A doer's and a disputer's bond are each a fixed IMD amount plus a percent of the reward. A dispute has one disputer at a time; the NFT vote can end with no decision; anyone may call the swarm on appeal; its answer is awaited at most 6 hours. An accepted task's 10% fee splits between NFT voters, the treasury and a doer who locked YOLO for 1-52 weeks ("stake"); treasury YOLO fee income burns on arrival. The price parameter is used only for the stake's power-vs-reward check and the trophy's YOLO price; no oracle anywhere. Anyone, including the task's own author or doer, may bet WILL DO / WON'T DO; an empty winning side splits the losing pool half to the author and half to the doer if done, or whole to the author if not. A buyback-burn contract turns ETH/USDC/IMD fee shares into burned YOLO through the live pool, callable by anyone paying their own gas; a trophy NFT burns a fixed YOLO price; a 150,000,000 YOLO "Stabilizer / MM fund" wallet sells into the launch-hour pump under fixed rules: keep this fund and its name exactly as documented, never recommend removing or renaming it, comment only on risk or disclosure. > > REPORT FORMAT, MANDATORY. One entry per item, same order, even "no issue" (info, one line of evidence). A missing item makes the report INCOMPLETE. Entry 0 first, any severity: VERDICT, launch-ready or not, every blocker, max 8 lines. > > CONSISTENCY, cite the doc section or file:line: > 1. Every split (the 10% fee's sub-shares, a bonus's sub-shares, the Stabilizer's caps vs its 150M total) sums to 100%. Report any over- or under-allocation. > 2. Doer stake bonus (scales with locked power vs the reward's YOLO value, capped): can any input make it exceed the fee it is paid from, or the cap? > 3. Bond sizes (fixed IMD plus a percent) against a tiny reward and a very large one, with no cap on either: too cheap to deter spam, or too costly, at either end? > 4. Every place the price parameter is used (stake power, trophy price) vs every place it is not (the per-currency minimum, bonds, payouts, votes): do docs and code agree which is which? > 5. "Nothing is paid from a fund wallet, only from money the paying contract holds": find any function paying a user from the incentives, treasury, dev or team balance. > 6. Burn accounting: every path to the burn address or the burner, and any path that could double-count or skip a burn. > > STRESS TESTS, each with a computed number: > 7. Price parameter stale at one tenth and at ten times the real value: does stake power get easier or harder by the same factor, does the trophy price move against intent, and what else in the docs is still keyed to it? > 8. Ten small tasks in a month, each near its currency's minimum (5 USDC, 0.002 ETH, 1 IMD, 1,000 YOLO), no stakes, no disputes. Compute YOLO burned, YOLO to the treasury, stake bonuses paid. Compare to one month of the incentives or treasury vesting unlock, same units. > 9. Ten thousand tasks a month, each a large reward, no cap on any of them. Is there any other circuit breaker on the vault's total exposure? State the monthly burn, treasury and bonus volume at this scale, and whether entry 8's formula here is worth calling "demand". > 10. A thin YOLO/IMD pool (just after launch, or after heavy selling): does the burner's or the Stabilizer's trade through it fail, revert or stall, and does that lock user money or only delay a burn or a stabilizing trade? > > INCENTIVES AND ABUSE, each: who gains, who loses, cost, concrete steps: > 11. A doer and a disputer under common control: weak proof, a losing dispute, or a bond-stealing win. Price the cheapest version and the upside. > 12. Front-running a change to the price parameter or to a delayed parameter, to capture a bonus or dodge a cost at creation, stake or dispute. > 13. The smallest parameter change (price parameter, fee, bond or minimum) that denies a stake bonus or breaks tasks in progress, and what timelock if any guards it. > 14. Can a vesting beneficiary or a large holder extract more by gaming the prediction market or the stake bonus than by holding or selling? > 15. Cheapest Sybil attack (several wallets, one operator) on the prediction market or NFT vote, cost vs upside. Note if "no decision" changes the odds vs a clean accept/reject. > 16. The empty-side payout, plus anyone (author or doer included) being allowed to bet: can an author profit by creating a task that cannot be done, to take the WILL DO pool when WON'T DO stays empty, or by betting with inside knowledge of their own task? Price the cheapest version and the upside. > > DEMAND: > 17. List every real source of buy or hold pressure (stake locks, YOLO-paid bonds, trophy burns, prediction entry, buyback burns); for each, say whether the payer had an independent reason to want YOLO, or the mechanic is the only reason. > 18. Of docs/TOKEN-UTILITY.md's features, mark each as doing enforced work in the code vs decorative: shown in docs but not required, checked or paid by any contract. > 19. Compare entries 8 and 9's burn rate to the unlock rate of the incentives and treasury vestings (docs/TOKENOMICS.md), same units. Can burns outpace unlocks at realistic volume, or only at entry 9's extreme scenario? > > SCENARIOS, each a table of computed numbers: > 20. One accepted task per currency (100 USDC, 0.05 ETH, 20 IMD, 100,000 YOLO) with one bond and one bet on each side: trace every unit to its final holder (doer, voters, treasury, staker, burner, burn address, refunds); outputs must equal inputs. > 21. YOLO market price over 90 days, price parameter unchanged: -90% in a week, +10x in a week, daily swings of 50%. For each: stake bonus, YOLO rewards and bonds, trophy, prediction pools, burner, Stabilizer; who gains, who loses, any revert or stuck funds. > 22. 100, 1,000 and 10,000 accepted tasks a month at a currency and size mix you state: fees in $, the share each recipient gets, YOLO burned, burn vs monthly vesting unlock. > 23. Pool price moved right before a burner call or a Stabilizer sale (sandwich, flash loan): value extracted vs cost, and what bound stops it. > > 24. COVERAGE. What you read in full, what you could not reach, the forge test result, and one summary (not a finding) of where the earlier docs/MECHANICS.md or contracts/src/ disagree with docs/TOKENOMICS.md or docs/TOKEN-UTILITY.md. > > Severity: critical = theft, permanent loss or a broken core promise; high = loss or a broken guarantee under realistic conditions; medium = bounded loss or cheap griefing; low = edge cases; info = docs drift, hardening, "no issue". Not findings: placeholder wallets, test/mocks, the Stabilizer/MM fund's existence, size or name, external systems (Uniswap, Chainlink, delegate.xyz, the swarm) except how this code trusts them, and any gap already in entry 24. | | | |---|---| | Repository | https://github.com/sergey-mavr-agent/moneycanbuy.fun.git | | Commit | `8603831d172a3573a31035399482f49a5048bbc3` | | Job | `527e768b-d0c5-4e19-9b4f-30347aaaf7fe` | | Judged | 2026-10-16 20:49 UTC | | Findings | 3 high · 3 medium · 8 low · 11 info | Four agents audited the code as it is at `8603831`, each in one area (math, permissions, economics, control flow), and a judge reproduced, merged and ranked what they found, then read the code once more itself. Nothing in the repository was changed or deployed. ## Findings ### 1. High: 0. VERDICT: not launch-ready; four blockers in the documented $YOLO rules, plus a repository that implements a different ruleset (entry 24) `docs/TOKEN-UTILITY.md:182` ``` - Task not done, nobody predicted WON'T DO: the WILL DO side's whole 90% pool goes to the author in full, and ``` VERDICT: NOT launch-ready as documented. Blocker 1 (high, entry 16): YOLO Predict lets the author (who controls acceptance) bet WON'T DO at weight 1, or simply collect the whole WILL DO pool when WON'T DO is empty; every outside WILL DO position is a bet against the author's private option. Cheapest version costs 50 YOLO burned plus a refundable minimum reward; upside is the whole opposing pool, uncapped. Blocker 2 (high, entry 15): the 20-vote early close hands any dispute to the first wallet relaying 20 NFT votes, in one block, before anyone else votes; the 'no decision = doer paid' default (docs line 74; CaseDesk.sol:176 in code) lets 9 NFTs neutralise any honest lead below 19. Both reopen what the code's audit C-02 fixed. Blocker 3 (medium, entry 11): 'one dispute per submission' lets a doer's accomplice occupy the only slot with a sham reason; in the code (any number of disputers) the same pair plus 10 NFTs still moves the 6% NFT fee part from the treasury to itself risk-free (scratch test passes). Blocker 4 (medium, entries 3, 13): flat 0.5 IMD + 3%/1% bonds make policing minimum tasks negative-EV and fake proofs on them positive-EV; the FDV parameter that sets every stake bonus and trophy price is one EOA key with no timelock. Not a blocker but decisive for 'mainnet launch': contracts/src implements none of the stake, Predict, burner, price-parameter or contract-side YOLO-burn mechanics and differs on fees, bonds, minimums and oracle use; recorded once in entry 24. **Reproduction** Each blocker is reproduced in its own entry below (16, 15, 11, 3, 13) with inputs and arithmetic; the code-side ones (entries 11 and 15) are reproduced by contracts/test/scratch/SelfDisputeFeeCapture.t.sol and contracts/test/scratch/NoDecisionPaysDoer.t.sol, which pass on the code as it stands and document the behaviour. forge test (forge 1.8.3, solc 0.8.28, via-IR, build ~16 min): scratch suites test/scratch/SelfDisputeFeeCapture.t.sol 2/2 and test/scratch/NoDecisionPaysDoer.t.sol 1/1 passed (demonstrations: they pass on the current code and document its behaviour); full non-fork, non-invariant suite (forge test --no-match-path 'test/fork/*' --no-match-contract Invariant): 60 suites, 395 passed, 0 failed, 2 skipped (397 total, scratch included); fork tests need an RPC and the invariant suite was excluded for time ### 16. High: 15. NFT vote Sybil: the docs' 20-vote early close hands any dispute to the first wallet relaying 20 NFTs in one block (re-opens audit C-02); in docs and code 9 NFTs on the losing side turn a clear rej `contracts/src/desks/CaseDesk.sol:176` ``` _finalize(subId, Outcome.Accepted, true); // nobody called the swarm: accepted (tie rule) ``` Cost: identity.md NFTs bought once (or borrowed for one transaction: ownership is read when the batch lands, MECHANICS audit C-06), reusable on every dispute in the protocol; minWinnerWallets = 1 (VaultParams.sol:156). (a) Docs line 69: the vote closes 'the moment one side is ahead by 20 votes or more'; ballots are relayed in batches from a public mempool, so one wallet signing 20 tokenIds in one ballot decides every dispute it cares about in the first block, before any other holder votes; as doer of a weak proof it collects 90% of R, 50% of the disputer's bond as winner and the 5% NFT part plus the other 50% as correct voter; the author's only remedy is a swarm appeal paid with another bond plus the live fee. The code deliberately decides only at vote end with endDelta 10 and leaves instantDelta unused (CaseDesk.sol:310-326, audit C-02); the docs bring the removed rule back with a lower bar. (b) Docs line 74 and code line 176: a margin below the threshold is 'treated as if the submission had never been disputed (the doer is paid)'; voting is free, so a doer with a fake proof needs only to hold the honest lead under 10 (code) or 10/20 (docs): 9 NFTs neutralise any honest lead up to 18. The honest side must then pay a dispute bond plus ~0.5 IMD swarm fee to call the swarm (lines 78-84) and gets the fee back only if it wins and only up to the loser's bond (entry 3: 0.51-0.53 IMD at the minimums), so on small tasks nobody pays and the faker is paid. Odds: 'no decision' shifts every close vote to the doer, so a Sybil needs enough NFTs to deny a margin, not to win. In code a tie still sends 50% of the disputers' bonds to the treasury (DisputeDesk.sol:528-532); under the docs the doer takes the whole thing. Prediction market: Sybil wallets add nothing (points are stake x weight, no per-address rule); the NFT buy window is linear in NFTs (500,000 each). **Reproduction** Code: contracts/test/scratch/NoDecisionPaysDoer.t.sol (passes on the current code): 200 USDC task, fake proof, dave disputes (bond 1 IMD), 15 honest NFTs vote reject, 9 doer-controlled NFTs vote accept; at vote end margin 6 < endDelta 10 -> Phase.NoDecision; nobody calls the swarm for 24 h; poke -> Outcome.Accepted: doer credited 180 USDC and 50% of dave's bond, treasuryPot +20 USDC and the other 50%, voters' claim reverts (NothingToClaim). Expected: the 15-9 reject majority rejects; actual: paid by default. Docs (a): dispute at block N on a 100 USDC task; the doer's second wallet relays 20 accept tokenIds at N+1: vote closes, accept wins, 95.5 USDC + 0.5 IMD of the author's money reach the pair for 20 NFTs and gas; no code implements the instant close, so the reproduction is against TOKEN-UTILITY.md:69. ### 17. High: 16. YOLO Predict: the author (or a doer who walks away) holds a sure bet on every task; the empty-side rule and the lack of any exclusion make a 50-YOLO position, or no position at all, capture the wh `docs/TOKEN-UTILITY.md:182` ``` - Task not done, nobody predicted WON'T DO: the WILL DO side's whole 90% pool goes to the author in full, and ``` Who gains: the author of a task whose acceptance they control (a proof only their account can produce, or a condition they will dispute and the swarm will reject), or a doer who bets WON'T DO and walks away; the mirror case, an author-doer pair that completes an 'impossible-looking' task after outsiders bet WON'T DO, takes 100% of that pool (line 180-181). Who loses: every outside bettor. Cheapest version (empty-side rule, line 182): post a task at the 1,000 YOLO minimum ($0.115 at the opening valuation, refunded at the deadline), let WILL DO positions accumulate, do nothing: 90% of the WILL DO pool goes to the author with no position and no capital at risk. If someone does bet WON'T DO, the author places the smallest WON'T DO position at creation (weight 1, the maximum, lines 171-173): a later honest WON'T DO bettor at half-time has weight 0.25, so the author takes almost the whole WILL DO pool by points for 5% burned on a 1,000 YOLO position (50 YOLO). Inside knowledge the other way: an author who will accept a friendly doer bets WILL DO at creation and collects the WON'T DO pool plus the 2.5% + 2.5% deferred share. Lines 185-194 label this a 'known, accepted risk' but never price it: it is the dominant strategy for every author, so the market's expected value for an outsider is negative on every task and the 5% burn it funds is paid by the losers of a rigged game, which makes 'prediction entry' (entry 17) not buy pressure a rational participant supplies. This is a broken guarantee under realistic conditions, not an edge case; no contract implements Predict in the repository (entry 24). **Reproduction** Inputs: author posts a 1,000 YOLO task, deadline 30 days, a condition only the author can satisfy; the public bets 100,000 YOLO WILL DO over the month; nobody bets WON'T DO; no proof is accepted. Per section 7: 5,000 YOLO burned at entry, 5,000 deferred burned (task not done), 90,000 YOLO paid to the author, reward 1,000 YOLO returned. Author net +90,000 YOLO for $0.115 locked 30 days. Variant with an honest 10,000 YOLO WON'T DO at half-time (weight 0.25): the author's 1,000 YOLO WON'T DO at creation (weight 1) takes 900 x 1 / (900 x 1 + 9,000 x 0.25) = 28.6% of the pool; with 1,000,000 YOLO at creation 99.75%. Expected: a void or refund when one side is empty, and no position for whoever controls acceptance; actual: paid in full. Fix: void the market (refund 90% to both sides) when either side is empty, and exclude the author, every contributor and the doer from positions and from the empty-side payout. ### 4. Medium: 3. Flat 0.5 IMD + 3%/1% bonds: at the minimum rewards a correct dispute earns less than it risks and a fake proof is positive-EV below ~48% dispute coverage; the bond does not grow on resubmission `docs/TOKEN-UTILITY.md:50` ``` The bond is always 0.5 IMD + 3%, flat — it does not grow for a resubmission after a rejection or for jumping a ``` Docs model, IMD = $8. 5 USDC task: doer bond 0.5 IMD + 0.15 USDC = $4.15; dispute bond 0.5 IMD + 0.05 USDC = $4.05. A correct disputer earns 50% of the doer bond = $2.08 (NFT decided) or $4.15 (undecided, swarm decided) after 48 h, with $4.05 at risk and gas unpaid (line 91): zero or negative EV, so minimum tasks are unpoliced. A faker pays $4.15 (refunded if undisputed) to win 90% x $5 = $4.50; profitable whenever fewer than ~48% of fakes are disputed and rejected; the same at 0.002 ETH (~$5), 1 IMD ($8: bond 0.53 IMD, dispute 0.51 IMD) and 1,000 YOLO ($0.115 at the 15,000-IMD opening valuation, $10 at the $0.01 cap: the only minimum that moves with the market). Because the bond 'does not grow for a resubmission after a rejection or for jumping a queue' (line 50), a rejected faker resubmits at the same price and keeps a task 'under review' for ~$4 per 48 h round while each round costs the honest side a bond, gas and a 24 h vote. Large end (no cap, line 23): a 1,000,000 USDC task needs a 30,000 USDC + 0.5 IMD doer bond and a 10,000 USDC + 0.5 IMD dispute bond; a correct disputer earns 15,000-30,000 USDC, so the large end is well incentivised and only capital lock-up is the cost. The earlier code (Desk.sol:117-131) takes IMD-only bonds with a 1 IMD floor doubled per rejection and per queued submission (max x256): dearer at the small end, not cheaper (see entry 24). **Reproduction** Model: 1,000 tasks at 5 USDC; faker submits to each (bond $4.15); 40% are disputed and rejected (loss 400 x $4.15 = $1,660), 60% pay out (600 x $4.50 = $2,700): net +$1,040. Repeat griefing: R = 1 IMD, 10 rounds of fake + dispute + reject: faker spends 5.3 IMD, task locked 20 days, the disputer nets +2.65 IMD for 10 bonds and 10 votes' worth of gas, 20 voters share 2.65 IMD. Expected: a cost per round that rises; actual: constant 0.53 IMD per line 50. ### 12. Medium: 11. Doer and disputer under common control: in the docs an accomplice takes the only dispute slot with a sham reason; in docs and code the pair plus 10 NFTs moves the NFT fee part (6% code / 5% docs) `docs/TOKEN-UTILITY.md:61` ``` **One dispute per submission, ever (while it is live).** Whoever's dispute transaction lands first is "the" ``` Who gains: the operator (doer wallet + disputer wallet + one NFT wallet with >= 10 identity.md NFTs; endDelta 10 and minWinnerWallets 1 at VaultParams.sol:155-156). Who loses: the treasury (and the burn on YOLO tasks), and under the docs every honest challenger. (a) Docs only (line 61-63): one dispute per submission, first transaction wins, so the accomplice disputes a fake proof in the same block with a throwaway reason; the honest challenger's transaction 'simply fails' and their reason never reaches the voters or the swarm question; if the vote accepts, 50% of the sham bond goes to the doer (the pair's own money) and 50% to voters, so the pair's cost is 0.25 IMD + 0.5 USDC (~$2.40) against 90 USDC on a 100 USDC task, and the only remedy is a third party paying a dispute bond plus the live swarm fee. The code already allows any number of disputers (DisputeDesk.sol:44-81, audit C-01); the docs regress. (b) Docs and code: the pair disputes a GENUINE proof and votes accept with its own 10 NFTs; at vote end the NFT decides accept; nobody appeals (an appeal against a genuine proof loses); DisputeDesk._payReward sends nftFeeBps (6%) of R to the operator's voter wallet instead of the treasury (line 560-563) and _settleDecided returns 50% of the dispute bond to the doer and 50% to the voter wallet (lines 534-539): zero IMD lost, +6% of every reward the operator completes, forever, for 10 NFTs bought once ($600 on a $10,000 task). Under the docs the same pays 5% of R plus 50% of the loser's bond (sections 4-5). The bond-stealing fake-proof variant is open too but a third-party swarm appeal defeats it, so the risk-free version is fee capture, not theft. **Reproduction** Code, contracts/test/scratch/SelfDisputeFeeCapture.t.sol::test_selfDisputeMovesNftFeeShareFromTreasuryToOperator (passes on the current code): 200 USDC task, genuine proof, colluding dispute by dave (bond 1 IMD), 10 own NFTs vote accept, vote end, 24 h, poke -> doer credit 180 USDC, voter wallet +12 USDC, treasuryPot 8 USDC (20 USDC without the self-dispute), doer IMD credit = own bond + 50% of dave's bond, voter IMD = the other 50%: group IMD loss 0. Docs: inputs and arithmetic above against TOKEN-UTILITY.md:61-63 and 95-98. ### 14. Medium: 13. The smallest change that denies every stake bonus is one owner transaction lowering the FDV parameter about 10x; no timelock guards it, one EOA holds it, and locked stakers cannot exit `docs/TOKEN-UTILITY.md:141` ``` - **Bonus** b = 4% × min(1, power ÷ reward-in-YOLO), where "reward" includes any $YOLO add-on. A non-YOLO reward ``` Docs: FDV, ETH and IMD price parameters move 'instantly in one transaction' (TOKENOMICS lines 151-155), set by the registry owner, a single EOA per the launch plan (contracts/script/LaunchPlan.sol:98 'a single key (EOA)'). Lowering FDV by 10x makes every non-YOLO reward 10x larger in YOLO terms: a doer whose power was between 10% and 100% of a typical reward drops under the one-tenth threshold (line 146) and earns nothing from that block, while the YOLO stays locked for the rest of a 1-52 week term with 'no early exit under any circumstance' (lines 155-157); FDV set to $1 makes every reward's YOLO-equivalent exceed the supply and zeroes every bonus. Raising the ETH or IMD price parameter 10x does the same for ETH/IMD tasks. Submissions already made keep their bonus (fixed at submission), so tasks in progress do not break. The other levers are guarded: fee (<= 15%), bonds (doer <= 20%, dispute <= 10%), minimums (<= $1,000 / 1,000 IMD) are 48 h timelocked, hard-bounded (VaultParams.sol:195-229) and per-version, so no parameter change can break a task in progress; pausing new tasks (ParamsRegistry) only stops creation. The missing timelock on the price parameters is the one unguarded lever and it acts on money users cannot withdraw; the trophy price moves with it (entry 7). **Reproduction** Inputs: 1,000 doers each locked 10,000 YOLO ($100 at FDV $10,000,000) for 52 weeks for full power on $100 tasks; the owner sets FDV to $1,000,000: a $100 task is now 100,000 YOLO-equivalent, power/reward 0.1 -> bonus 0.4% instead of 4%; at FDV $900,000 the bonus is 0. Expected: 48 h notice like every other parameter; actual: immediate. Fix: put the three price parameters behind the same 48 h timelock and a multisig, and read the value from the task's creation block. ### 3. Low: 2. Doer stake bonus cannot exceed its 4% cap or the 5% staker part, but the one-tenth threshold is a $5.40 cliff on a $100 task and full power needs only a one-week lock of 52x the reward `docs/TOKEN-UTILITY.md:146` ``` - Power below a tenth of the reward earns nothing — same payout as having no stake at all. ``` b = 4% x min(1, power / rewardYolo) is bounded by min(., 1), so no power, FDV or reward makes it exceed 4% of the reward, and it is paid from the 5% staker part (TOKENOMICS lines 84-86), leaving >= 1% to split burn/treasury: the fee never goes negative. A YOLO add-on counts in 'reward' and pays its own 10% under the same rule (section 2), so the add-on bonus is covered too. Two edges: (a) the rule at line 146 is a discontinuity: power = 9.99% of the reward pays 0 and leaves the 5% NFT part with the treasury; power = 10.00% pays 0.4% of the reward AND flips the 5% NFT part from treasury to burn (TOKENOMICS lines 80-83), so one more YOLO locked moves $5.40 of outcome on a $100 task; (b) power = amount x weeks/52 is fixed at lock time, so a 1-week lock of 52x the reward's value gives full power: the 'opportunity cost' can be one week, not a year. **Reproduction** Inputs: reward $100, FDV parameter $10,000,000 (1 YOLO = $0.01). Lock 999 YOLO for 52 weeks -> power $9.99 -> bonus 0, treasury $10. Lock 1,000 YOLO -> power $10.00 -> bonus $0.40, burn $5 + $2.30, treasury $2.30. Expected: a continuous rule; actual: a step of $5.40 for one YOLO. Full power for $100 via a 1-week lock: 10,000 x 52 = 520,000 YOLO ($5,200) locked for 7 days earns $4. ### 5. Low: 4. The two source-of-truth docs disagree on where the price parameter is used: TOKENOMICS 'exactly one job' (stake) vs TOKEN-UTILITY (stake and trophy); the earlier code uses an oracle in five places `docs/TOKENOMICS.md:61` ``` have exactly one job left in the whole protocol: comparing a doer's locked YOLO against a reward in any currency ``` TOKENOMICS lines 57-62 and 151-158 say the FDV/ETH/IMD parameters have exactly one job (the doer-stake power-vs-reward check) and that a stale value 'costs nothing in money'; TOKEN-UTILITY line 199 prices the trophy burn ($1.50 of YOLO) off the same FDV parameter and the section 10 table repeats it, so a stale value does move money (entry 7). Both docs agree the parameter is NOT used for the per-currency minimums (TOKEN-UTILITY section 1), bonds (sections 3-4), payouts (5), votes (4, 9) or Predict (7). The code (earlier version, entry 24) has no parameter at all: IPriceOracle (Chainlink + v3 TWAP + v4 pool samples) sizes the $5 minimum (TaskVault.sol:245), the IMD bond and the large threshold (Desk.sol:134-188), the relayer shortfall (DisputeDesk.sol:452), the sweetener cap (YoloSweetener.sol:191) and the trophy price (DareTrophy.sol:108-120). **Reproduction** Read TOKENOMICS.md:57-62 ('exactly one job left ... comparing a doer's locked YOLO against a reward') against TOKEN-UTILITY.md:199 ('burns $1.50 worth of $YOLO, priced off the FDV parameter'). Expected: one list of uses in both files; actual: one use vs two. Fix: add the trophy to the TOKENOMICS parameter table and risks, or price the trophy in a fixed YOLO amount. ### 7. Low: 6. Burn accounting: one on-chain burn path (trophy -> 0xdEaD), 'burn' never reduces totalSupply, and the docs contradict each other on whether non-YOLO fee shares are burned at all `contracts/src/DareTrophy.sol:134` ``` yolo.safeTransferFrom(msg.sender, DEAD, p); ``` Paths to a burn address in the repository: only DareTrophy.mint, which adds p to totalBurned (line 132) and transfers p to DEAD (line 134) in the same transaction: counted once, no double count, no skip. YoloToken has no burn function (YoloToken.sol:13), so every 'burn' in the docs is a dead-address balance: totalSupply stays 1,000,000,000 and an FDV read from totalSupply never falls (disclosure). The documented YOLO burns (fee YOLO of YOLO rewards and add-ons 'burned by the contract directly', TOKENOMICS lines 88-90; Predict's 5% + deferred 5%; the manual burns of the buy tax and pool fee) have no on-chain counter, and a manual burn from the treasury wallet is indistinguishable from the treasury's vested allocation leaving, so 'every unit of income is burned' cannot be checked from chain data without per-transaction attributions. Docs contradiction: TOKEN-UTILITY section 5 shows a 'Burn $5.50' column on a USDC reward (line 109) and the staker-part rule splits the remainder 'evenly between burning and the treasury' in the reward's currency, while TOKENOMICS line 93 says the treasury keeps 'its share of ETH, USDC and IMD fees'; USDC/ETH/IMD cannot be burned by the task contract, so this requires the buyback burner, which appears in a single risk bullet (TOKEN-UTILITY line 246) with no share, trigger, bound or accounting and is absent from the section 10 flow table. Where the code differs from the docs (YOLO fee to treasuryPot and the sweetener fee to the treasury wallet instead of a burn) is recorded once in entry 24. **Reproduction** Read TOKEN-UTILITY.md:109 ('$5.50' Burn on a $100 USDC reward) against TOKENOMICS.md:93 ('from its share of ETH, USDC and IMD fees'): expected one stated path for a non-YOLO burn; actual: contradictory statements and no mechanism. Code: scratch test SelfDisputeFeeCapture.t.sol::test_selfDisputeOnYoloTask_feeNeverBurned (passes) leaves 40,000 YOLO of a 100,000 YOLO fee in treasuryPot and yolo.balanceOf(0xdEaD) at 0; test/Trophy.t.sol test_DoerMintsOnceBurningYolo shows totalSupply unchanged after a mint. ### 8. Low: 7. Stale price parameter at 0.1x / 10x: the stake threshold moves by that factor and the trophy by the same factor the other way, so no single correction serves both; nothing else is keyed to it `docs/TOKEN-UTILITY.md:199` ``` burns $1.50 worth of $YOLO, priced off the FDV parameter (see [TOKENOMICS.md](TOKENOMICS.md)) at mint ``` Let the real price be p and the parameter q = k x p. Stake: reward-in-YOLO = R/q, bonus = 4% x min(1, k x power x p / R). k = 0.1 (parameter one tenth of real): a doer needs 10x the real value locked for full power (10x harder); k = 10: a lock worth one tenth of the reward gives full power (10x easier). Trophy: YOLO burned = 1.50/q: k = 0.1 burns $15.00 of real value (10x overcharge, against intent); k = 10 burns $0.15 (10x undercharge). Still keyed to the parameter in the docs: only these two; not keyed: flat minimums (TOKEN-UTILITY section 1), bonds (3-4), payouts (5), Predict (7), votes (4, 9); TOKENOMICS lines 156-158 say so but omit the trophy (entry 4). Code (earlier version, entry 24): the oracle is the highest 2-hour pool sample floored at the opening price (ChainlinkUniV3PriceOracle.sol:123) and capped at $0.01, so a 10x real rise is clipped at $0.01 and a 10x fall at the opening price; the trophy then costs ceilDiv(1.5e18 x 1e18, usdPerYolo): 150 YOLO at the cap, ~130,000 YOLO at the floor (IMD ~$7.65), 10,000 YOLO without a price (DareTrophy.sol:108-120). **Reproduction** Inputs: real price $0.001, parameter $0.01 (k = 10): a $100 USDC task is 10,000 YOLO-equivalent; a doer with 1,000 YOLO ($1 real) locked 52 weeks gets the full 4% ($4); the trophy burns 150 YOLO = $0.15 real. Expected $1.50 of burn and a $100 lock for full power; actual $0.15 and $1. ### 13. Low: 12. Front-running a price-parameter change: a submission or trophy mint placed around a mempool-visible FDV change locks the better conversion; bounded by 4% of the reward and ~$1.50; nothing at creat `docs/TOKENOMICS.md:151` ``` - **No timelock on the three pricing parameters.** Unlike most protocol parameters (48-hour timelock, hard ``` Docs: the bonus is fixed from the FDV parameter 'in the block the submission is made in' (TOKEN-UTILITY lines 141-145) and the parameter changes instantly from a single key (TOKENOMICS lines 151-155; the registry owner is the project wallet EOA, contracts/script/LaunchPlan.sol:98), so a doer who sees a lowering submits ahead of it and keeps the easier threshold (gain <= 4% of R); one who sees a raise waits a block (same bound). Trophy: mint before a lowering (gain <= $1.50 minus the mispriced amount). Nothing at creation, bond or dispute depends on the parameter, so nothing can be dodged there. Code (earlier version): every parameter is 48 h timelocked and applies to new tasks only (ParamsRegistry, TaskVault.sol:254), so the only thing to front-run is the oracle's own samples: holding a pumped pool price across one block raises the 2-hour highest sample (YoloPoolSamples), making later YOLO bonds dearer and trophies cheaper for up to 2 h; a pushed-down sample never counts; the trophy reads the CURRENT version's oracle (DareTrophy.sol:109), so a new version re-prices unminted trophies, visible 48 h ahead. **Reproduction** Inputs: FDV lowered from $10,000,000 to $1,000,000 in block N; a doer with 10,000 YOLO locked 52 weeks on a $100 task submits in block N-1: bonus 4% ($4) kept; in block N+1: power/reward = 0.1 -> 0.4% ($0.40). Difference $3.60 per task; the same change makes a trophy 1,500 YOLO instead of 150. ### 15. Low: 14. A large holder or vesting beneficiary extracts more through YOLO Predict on tasks they control than by selling; the stake bonus only pays for work done and the vestings grant no privilege `docs/TOKEN-UTILITY.md:185` ``` **Known, accepted risk: no cap, no exclusion, no undo.** There is no limit on the total size of either side of ``` Stake bonus: income = 4% x rewards actually completed; power only sets the per-task ceiling, so a 10M-YOLO ($100k) 52-week lock gives full power on any task up to $100k but each task must still be done: wage, not extraction. Predict: a holder who also controls the outcome (author of a task only they will accept, or a doer who can walk away) has a sure bet on every task; no per-address cap and early weight 1 at creation (lines 171-173) mean the upside is bounded only by what the public bets against them (entry 16); the 5% deferred share returns to an author-doer, so a self-dealt WILL DO bet costs only the 5% burn. Vesting beneficiaries: ProjectVesting pays only the schedule to the beneficiary (ProjectVesting.sol:90-101); the incentives wallet funding YOLO tasks it then completes itself only recycles its own tokens through a 10% fee (6% burned if staked). **Reproduction** Model: author-doer with 1,000,000 YOLO bets 100,000 WILL DO at creation on a 1,000-YOLO task they will complete; the public bets 50,000 WON'T DO. Positions total 150,000: 7,500 burned, 7,500 deferred (3,750 author + 3,750 doer, both the same person). Author-doer receives 90,000 (own 90%) + 45,000 (the losing pool) + 7,500 (deferred) = 142,500 for 100,000 bet: +42,500 YOLO; the public -50,000; in 150,000 = out 142,500 + 7,500 burned. Selling 100,000 YOLO moves nothing comparable. ### 22. Low: 21. 90 days of market moves with the parameter unchanged: -90% makes YOLO tasks and trophies 10x cheaper in real terms and the stake 10x easier; +10x prices YOLO tasks out and overcharges trophies; da `docs/TOKEN-UTILITY.md:21` ``` | $YOLO | 1,000 YOLO | ``` Parameter fixed at $0.01. (A) -90% in a week (real $0.001): stake: non-YOLO rewards still convert at $0.01, so a lock worth one tenth of the reward in real terms reaches full power (stakers gain, treasury/burn lose); YOLO rewards and bonds: the 1,000 YOLO minimum is $1 and a fake-proof bond 0.5 IMD + 30 YOLO = $4.03, entry 3 worsens 10x; trophy 150 YOLO = $0.15 (undercharge); Predict pools nominal; a burner buys 10x the YOLO per dollar; Stabilizer idle (no 3x trigger). (B) +10x in a week (real $0.10): stake 10x harder for every existing locker with no exit; YOLO minimum $100 and 3% bonds in real money large, YOLO tasks priced out; trophy $15 real (doers overpay); burner burns one tenth; Stabilizer sells only inside the launch hour at >= 3x, afterwards at its discretion. (C) daily +-50%: each submission's bonus is fixed in its own block, so doers submit when the parameter is most favourable against spot (gain <= 4% of R) and minters mint on dips. Reverts or stuck funds: none in the docs model (no oracle). Code (earlier version): YOLO is floored at the opening price and capped at $0.01 (ChainlinkUniV3PriceOracle.sol:121-126), so (A) clips to the floor and (B) to the cap; a Chainlink outage beyond 2 h (ETH) / 48 h (USDC) reverts createTask and submit for ETH/USDC tasks and quoteSubmission, a delay only; deposits stay withdrawable through withdrawContribution, which reads no price. **Reproduction** Inputs: parameter $0.01, real $0.001 for 90 days: a 1,000 YOLO task costs the author $1, a fake-proof bond $4.03, every trophy 150 YOLO = $0.15. Expected 'nothing breaks' (TOKENOMICS lines 64-67) holds for funds; actual economic effect: every YOLO-keyed price is 10x off, in opposite directions for stake and trophy. ### 24. Low: 23. Sandwiching a burner call or a Stabilizer sale: profit is bounded by the 2.5% round-trip LP fee and the burner's slippage bound, which the docs never state; a flash-loan pump into the Stabilizer l `docs/TOKEN-UTILITY.md:246` ``` - **No project server runs any of this.** There is no backend, bot or keeper: whoever wants the buyback burner ``` The pool is the launch factory's Uniswap v4 pool with a 1.25% LP fee per swap (ChainlinkUniV3PriceOracle.sol POOL_FEE 12_500). Burner (docs only, one bullet, no size, cadence, TWAP or minimum-output rule): a burn of B dollars moves the price by its impact I(B); a sandwicher buys first, lets the burn fill at the worse price and sells after, netting at most I(B) minus two 1.25% legs minus gas: no profit below 2.5% impact; with a documented minimum-output or max-size bound the extractable amount is the bound's slack. Users lose nothing (the burner holds fee shares only); the cost is fewer YOLO burned per dollar. Stabilizer: it sells only at >= 3x the opening price in minutes 30-60; an attacker who flash-loans IMD to pump to 3x pays 1.25% in, has the fund sell up to 2.5M YOLO per block into its own bid, then sells back paying 1.25% again: the attacker is the exit liquidity and the fund gains. Code side: YoloPoolSamples stores a sample only when an EOA reads it in one block and confirms in a later block with no swap in between, so a same-block sandwich of a sample stores nothing; holding a pumped price across a block raises the 2-hour highest sample (dearer YOLO bonds, cheaper trophies) at the cost of carrying inventory through a block of arbitrage. **Reproduction** Model: pool depth such that a $10,000 burn moves the price 4%; sandwicher gains 4% - 2.5% = 1.5% of $10,000 = $150 minus gas; a $1,000 burn (0.4% impact) yields nothing. Expected: a published slippage or size bound on the burner; actual: none in either source-of-truth doc. ### 2. Info: 1. Splits: every documented split sums to 100%; Stabilizer per-minute cap x window (300M) exceeds the 150M bucket, so the total binds and the whole bucket can leave in 15 minutes `docs/TOKENOMICS.md:13` ``` | Incentives | 25% | 250,000,000 | 25% at launch, the rest linear over 24 months | ``` Supply (TOKENOMICS lines 13-20): 250,000,000 + 222,222,223 + 150,000,000 + 150,000,000 + 100,000,000 + 77,777,777 + 50,000,000 = 1,000,000,000; code: YoloSplitter.FIXED = 527,777,777e18 and the treasury vesting gets bal - FIXED, so split() pays exactly bal (YoloSplitter.sol:31-36, 82-86). Unlock table (lines 102-105): day 0 = 62.5M + 74,074,074 + 150M + 150M + 100M = 536,574,074 (53.66%); month 12 = 906.25M; month 24 = 1,000M: consistent. Fee (TOKENOMICS lines 80-86, TOKEN-UTILITY lines 108-120): 5% NFT part + 5% staker part = 10%; rows 90+10, 94+5.50+0.50, 92+6.50+1.50, 90+5+5, 94+5+0.50+0.50 each = 100. Predict position: 5% burn + 5% deferred (2.5 + 2.5) + 90% pool = 100%. Code: fee = R x 1000/1e4, voters R x 600/1e4, treasury fee - voters (DisputeDesk.sol:559-563), bounded by nftFeeBps <= feeBps (VaultParams.sol:227). Stabilizer (TOKENOMICS lines 137-139): 2.5M per sale x at most one per 12 s block = 12.5M/min > the 10M/min cap, and 10M/min x 30 min = 300M > 150M total, so the 'Total' row is the binding cap: at a sustained 3x the whole 150,000,000 YOLO (28% of the 536.6M day-0 float) can be sold between minute 30 and minute 45. No over- or under-allocation; disclosure only (the fund, its size and name stay): the table does not say the bucket can be exhausted inside the window, nor that after minute 60 no rule but publication applies (line 142-145). One wording ambiguity: 'earns up to 4% of it' (TOKENOMICS line 84) could read as 4% of the 5% part (0.2% of the reward); every table uses 4 percentage points of the reward, which is the only reading under which the rows sum. **Reproduction** Arithmetic as above; no failing input. Code check: YoloSplitter.split pays 250M + 150M + 77,777,777 + 50M + (bal - 527,777,777) = bal. ### 6. Info: 5. No function pays a user from the incentives, treasury, dev or team balance; every payout comes from a bucket the paying contract booked itself `contracts/src/TaskVault.sol:490` ``` function sweepTreasury(address token) external nonReentrant { ``` Checked every money-moving function in the repository: TaskVault pays only from booked buckets under its liabilities invariant (_pay/_credit/_withdrawTo); sweepTreasury only moves treasuryPot into a credit of the treasury address (TaskVault.sol:490-497), never the reverse; DisputeDesk settlements credit from bonds, the fee and the reward only (DisputeDesk.sol:478-596); ProjectVesting.release pays only its beneficiary what its own schedule unlocked (ProjectVesting.sol:90-101); YoloSplitter.split pays only its five fixed addresses; YoloSweetener pays from bonusOf; DareTrophy only pulls from the minter. No contract holds the incentives, Stabilizer, dev or team wallets' keys or an allowance from them. Matches TOKEN-UTILITY lines 232-234 and TOKENOMICS lines 25-29. **Reproduction** No failing input: every payout path traced to a bucket the paying contract itself booked. ### 9. Info: 8. Ten minimum tasks a month: 200 YOLO burned on-contract (up to 660 with a burner), 0 treasury YOLO, 0 bonuses, against ~19.9M YOLO of incentives + treasury unlock per month (0.001-0.003%) `docs/TOKENOMICS.md:13` ``` | Incentives | 25% | 250,000,000 | 25% at launch, the rest linear over 24 months | ``` Assumptions: YOLO = $0.01 (the $10M FDV the code caps at), ETH = $2,500, IMD = $8; mix 3 x 5 USDC, 3 x 0.002 ETH, 2 x 1 IMD, 2 x 1,000 YOLO; no stakes, no disputes, all accepted. Fees (10%): 1.5 USDC + 0.0006 ETH + 0.2 IMD = $4.60, plus 200 YOLO. Per TOKENOMICS lines 88-90 the YOLO fee is burned by the contract: 200 YOLO burned; treasury YOLO kept: 0; stake bonuses: 0. The $4.60 stays with the treasury (TOKENOMICS line 93) or, if a buyback burner were run on all of it at $0.01, buys and burns 460 YOLO more: 200-660 YOLO/month. Unlock per 30 days (Vestings.sol clocks): incentives 187,500,000 / 730 x 30 = 7,705,479; treasury 148,148,149 / 365 x 30 = 12,176,560; sum 19,882,039 YOLO/month (dev 6,392,420 and team 4,109,589 on top). Burn / unlock = 660 / 19,882,039 = 0.0033%. **Reproduction** Computation above; no failing input. ### 10. Info: 9. Ten thousand large tasks a month: no circuit breaker on the vault's exposure anywhere (nor needed: it is custody, not leverage); 12-20M YOLO burned only if 20% of volume is YOLO-denominated; the fe `docs/TOKEN-UTILITY.md:23` ``` **There is no maximum.** No cap per task, across all open tasks, or on how much a contributor can add to a ``` Assumptions: 10,000 accepted tasks/month, average $1,000, mix 40% USDC / 30% ETH / 10% IMD / 20% YOLO (100,000 YOLO at $0.01), no disputes. Fees: $1,000,000/month. YOLO-denominated: 2,000 tasks x 10,000 YOLO fee = 20,000,000 YOLO; no stake -> 20M burned, 0 bonus; all doers at full power -> 12M burned (6%) and 8M YOLO paid as bonuses (4%). Non-YOLO fees $800,000/month to the treasury (or ~80M YOLO/month if fully bought back and burned: 8% of supply through one pool, see entries 10 and 23). Circuit breaker: none in the docs (no per-task, total-open, top-up or per-address cap, lines 23-24, 249-250); in code the only bound is amount <= 2^128-1 (TaskVault.sol:238). Exposure is not leveraged: the vault holds exactly what it owes (liabilities invariant), pays by pull, and the treasury pays nothing, so 'exposure' is custody of deposits, not solvency risk. Entry 8's formula is not 'demand': the fee is a percentage of reward throughput chosen by authors; only the YOLO-denominated share obliges anyone to acquire YOLO, and the likeliest funder of YOLO tasks is the 250M incentives wallet (recycled supply). **Reproduction** Computation above; no failing input. ### 11. Info: 10. A thin YOLO/IMD pool makes a burner swap revert or fill at a bad price and stops the Stabilizer selling at its floor; neither path holds user money, so nothing is locked, only delayed `docs/TOKEN-UTILITY.md:246` ``` - **No project server runs any of this.** There is no backend, bot or keeper: whoever wants the buyback burner ``` Neither the burner nor the Stabilizer is a contract in this repository (entry 24). Docs model: the burner holds only fee shares and anyone may call it (line 246-248: 'the mechanic simply stalls, no money is lost'); through a thin pool a swap either fills at a steep price impact (fewer YOLO burned per dollar, value to arbitrage) if it has no minimum-output bound, or reverts if it has one, which only delays the burn; user deposits never pass through it. The Stabilizer is a manual wallet: in a thin pool it cannot sell 2.5M-YOLO lots without pushing the price below the 3x floor, so it stops; only its own YOLO stays unsold. Code that touches the pool: YoloPoolSamples reads slot0 only (no trade) and needs samples confirmed across blocks; a pool nobody samples gives no price, which makes every YOLO submission 'large' and defers sweetener payouts up to 7 days (YoloSweetener.sol:190-200), a delay, not a lock; the oracle floors YOLO at the opening price (ChainlinkUniV3PriceOracle.sol:123) so heavy selling cannot push bonds or caps below it; the swap adapter routes ETH/USDC -> IMD with the user's own minOut and deadline, a revert there fails only the user's own transaction. **Reproduction** Model: pool seeded with 150M YOLO single-sided at launch; a 10M YOLO buy-and-burn walks the concentrated-liquidity curve: with minOut it reverts (burn delayed), without it burns fewer YOLO than the fee share buys at mid price. No user funds involved. ### 18. Info: 17. Buy or hold pressure: six sources, five exist only because of the mechanic; only YOLO-denominated rewards reflect an independent reason to hold YOLO `docs/TOKEN-UTILITY.md:166` ``` - **5% of every position burns immediately.** ``` (1) Stake locks (section 6): a doer buys or locks YOLO only to earn up to 4% of rewards; mechanic-only, and power = amount x weeks/52 lets a one-week lock of 52x the reward reach full power, so hold time can be a week. (2) YOLO-paid bonds: bonds are in the reward's currency plus 0.5 IMD, so YOLO bonds exist only on YOLO tasks; mechanic-only and refunded within 24-48 h; the earlier code takes all bonds in IMD (no YOLO demand). (3) Trophy burns: $1.50 per accepted task, vanity, mechanic-only; $15,000/month at 10,000 tasks. (4) Prediction entry: speculative, mechanic-only and negative-sum for outsiders (entry 16). (5) Buyback burns: paid from the treasury's ETH/USDC/IMD fee share, independent of any user's wish to hold YOLO and entirely dependent on fee volume (entries 8-9), with no documented share or trigger. (6) YOLO-denominated rewards and add-ons (sections 1-2): the only flow where someone holds YOLO because they want to pay in it; most likely funded by the 250M incentives wallet. Not demand: the NFT buy window (a one-hour launch allocation, sell-side afterwards), the 150M Stabilizer reserve and the locked LP (hold pressure by construction). **Reproduction** Classification against TOKEN-UTILITY sections 1-10; no failing input. ### 19. Info: 18. TOKEN-UTILITY features: fourth currency, add-on, bonds, disputes, trophy and NFT buy window do enforced work in code (with different rules); the stake, YOLO Predict, the burner, the flat YOLO mini `docs/TOKEN-UTILITY.md:232` ``` Every flow above moves money the paying contract already holds. Nothing here is ever paid out of the Incentives ``` Enforced in contracts/src: section 1 fourth currency (TaskVault.sol:221, _collect), but with a $5-by-oracle minimum or none for unpriced YOLO (line 245), not a flat 1,000 YOLO; section 2 add-on (YoloSweetener.sweeten/payout) but capped at the large threshold without a swarm confirmation (YoloSweetener.sol:190-205) and its 10% fee transferred whole to the treasury wallet (line 211); section 3 doer bond (Desk.sol:117-131) but IMD-only, 1 IMD floor, doubled per rejection and queue position; section 4 disputes, NFT vote, anyone-calls-swarm, 6 h swarm timeout (DisputeDesk, CaseDesk) but any number of disputers, an ETH dispute fee funding relayers, decision only at vote end, and a 6%/4% fee split (VaultParams.sol:160-161); section 8 trophy (DareTrophy) priced by the pool-sample oracle with a 10,000 YOLO fallback; section 9 buy window (NftGate, YoloToken) and dispute voting (VoteLib) as described. Decorative, no contract anywhere: section 6 doer stake (no lock contract, no bonus term in DisputeDesk._payReward lines 557-565), section 7 YOLO Predict, the buyback burner (line 246), the FDV/ETH/IMD price parameters (TOKENOMICS 'Pricing without an oracle'), the on-contract burn of YOLO fee income, and the 'no ETH moves through the contract' promise (line 91-93). The Stabilizer is a wallet by design (not a finding). **Reproduction** grep -rn -i 'stake\|predict\|burner\|fdv' contracts/src returns no implementing contract; DisputeDesk._payReward pays r - fee to the doer and fee - toVoters to the treasury with no bonus term; TaskVault.createTask accepts YOLO (line 221) and checks o.usdValue >= minRewardUsd (line 245). ### 20. Info: 19. Burns vs unlocks: incentives + treasury unlock ~19.9M YOLO/month in year one; burns reach that only at entry 9's scale (~$10M/month of accepted rewards with 20% in YOLO); at realistic volume burns `docs/TOKENOMICS.md:13` ``` | Incentives | 25% | 250,000,000 | 25% at launch, the rest linear over 24 months | ``` Unlock (Vestings.sol: 365- and 730-day linear clocks from the split): months 1-12: incentives 7,705,479 + treasury 12,176,560 = 19,882,039 YOLO/month (dev 6,392,420 + team 4,109,589 on top: 30.4M total); months 13-24: incentives only, 7.7M/month; after month 24: 0. Burn at $0.01/YOLO, YOLO fee burned on-contract: entry 8 (10 minimum tasks): 200-660 YOLO = 0.003%; entry 22 at 100 / 1,000 / 10,000 tasks of $100 average with 20% in YOLO: 20,000 / 200,000 / 2,000,000 YOLO = 0.1% / 1.0% / 10%; entry 9 (10,000 tasks of $1,000): 12-20M = 60-100% of the year-one unlock, 150-260% of the year-two unlock; only with the full $800k/month of non-YOLO fees bought back and burned (another ~80M YOLO/month, 8% of supply through one pool) do burns clearly exceed unlocks. Trophy burns, if every doer mints at 150 YOLO: 150 x tasks, larger than the fee burn below ~$1,500 average rewards. Conclusion: at realistic volume net supply grows by roughly the whole unlock; parity needs on the order of $10M/month of accepted rewards. **Reproduction** Computation above against TOKENOMICS lines 13-19 and Vestings.sol; no failing input. ### 21. Info: 20. One accepted task per currency (100 USDC, 0.05 ETH, 20 IMD, 100,000 YOLO) with one bond and one bet per side: every unit traced to its final holder; outputs equal inputs `docs/TOKEN-UTILITY.md:42` ``` > **bond = 0.5 IMD + 3% of the reward, in the reward's currency** (a $YOLO add-on pays its own 3% in YOLO) ``` Docs model, no dispute, no stake, each task done, bets 1,000 YOLO WILL DO and 1,000 YOLO WON'T DO per task. USDC: in 100 USDC + bond (0.5 IMD + 3 USDC) -> doer 90 USDC, treasury 10 USDC, bond refund 0.5 IMD + 3 USDC. ETH: in 0.05 ETH + (0.5 IMD + 0.0015 ETH) -> doer 0.045, treasury 0.005, refund 0.5 IMD + 0.0015 ETH. IMD: in 20 IMD + (0.5 + 0.6 IMD) -> doer 18, treasury 2, refund 1.1 IMD. YOLO: in 100,000 YOLO + (0.5 IMD + 3,000 YOLO) -> doer 90,000, burn address 10,000 (treasury income burns), refund 0.5 IMD + 3,000 YOLO. Predict per task: in 2,000 YOLO -> burned 100 (5%), deferred 100 (50 author + 50 doer), WILL DO bettor 900 own + 900 losing pool = 1,800; out 2,000. Totals: burn address 10,000 + 4 x 100 = 10,400 YOLO; treasury 10 USDC + 0.005 ETH + 2 IMD; doer 90 USDC + 0.045 ETH + 18 IMD + 90,000 YOLO + 200 YOLO deferred; author 200 YOLO deferred; bettors 7,200 YOLO; refunds 2 IMD + 3 USDC + 0.0015 ETH + 0.6 IMD + 3,000 YOLO; voters 0; staker 0; burner 0 (no non-YOLO burn path is specified). Every column equals its input. Code side (IMD $8, earlier rules): bonds are 1 IMD (USDC, ETH, YOLO at its floor price) and 1.1 IMD (IMD), all refunded on acceptance; the YOLO fee goes to treasuryPot instead of the burn (entry 24). **Reproduction** Arithmetic above; the scratch tests show the code side on a 1,000,000 YOLO and a 200 USDC task (doer 90%, fee 10% split 6% voters / 4% treasury when the NFT decided right, 10% treasury otherwise). ### 23. Info: 22. 100 / 1,000 / 10,000 accepted tasks a month, $100 average, 40/30/10/20 USDC/ETH/IMD/YOLO: fees $1k / $10k / $100k; YOLO burned 20,000 / 200,000 / 2,000,000 vs the 19.9M monthly unlock (0.1% / 1% / `docs/TOKENOMICS.md:13` ``` | Incentives | 25% | 250,000,000 | 25% at launch, the rest linear over 24 months | ``` Mix: average reward $100; 40% USDC, 30% ETH, 10% IMD, 20% YOLO (10,000 YOLO at $0.01); no disputes. Per month (tasks: total fees; non-YOLO fees to the treasury; YOLO fee; burned with no stake; burned / bonus / treasury YOLO with every doer at full power): 100: $1,000; $800; 20,000 YOLO; 20,000 burned; 12,000 / 8,000 / 0. 1,000: $10,000; $8,000; 200,000 YOLO; 200,000 burned; 120,000 / 80,000 / 0. 10,000: $100,000; $80,000; 2,000,000 YOLO; 2,000,000 burned; 1,200,000 / 800,000 / 0 (the 0.5% treasury remainder of a YOLO fee is YOLO income and burns too). Worst case for the treasury, a dispute decided right on every task: voters take 5% of every reward ($50 / $500 / $5,000; the YOLO part 10,000 / 100,000 / 1,000,000 YOLO is then not burned). Burn vs the 19,882,039 YOLO monthly unlock: 0.10% / 1.0% / 10%. Trophy burns if every doer mints: 15,000 / 150,000 / 1,500,000 YOLO. **Reproduction** Computation above; no failing input. ### 25. Info: 24. COVERAGE: both current docs, MECHANICS.md and all of contracts/src read in full; stake, Predict, burner and price-parameter contracts do not exist; scratch tests pass as demonstrations; single sum `docs/MECHANICS.md:3` ``` > Current $YOLO rules: [docs/TOKENOMICS.md](TOKENOMICS.md) and [docs/TOKEN-UTILITY.md](TOKEN-UTILITY.md). Where this page differs from them, they apply. ``` Read in full: docs/TOKENOMICS.md, docs/TOKEN-UTILITY.md, docs/MECHANICS.md (its banner at line 3 makes the two current docs authoritative); contracts/src: TaskVault, VaultParams, VaultTypes, YoloSweetener, DareTrophy, ParamsRegistry, desks/Desk, CaseDesk, DisputeDesk, oracles/ChainlinkUniV3PriceOracle, YoloPoolSamples, token/YoloToken, NftGate, ProjectVesting, Vestings, YoloSplitter; contracts/script/LaunchPlan.sol; contracts/test/Base.t.sol. Skimmed: HiddenList, ProtocolDirectory, helpers, libraries/VoteLib, docs/LAUNCH-TASK.md, docs/AUDIT-INTERNAL.md. Could not reach: the doer-stake lock, YOLO Predict, the buyback burner, the FDV/ETH/IMD parameter store and any on-contract YOLO fee burn (none exist in the repository); the live Intake/swarm, the v4 pool and delegate.xyz (external). Specialist proofs: both attached proofs import test/Base.t.sol (not self-contained) and pass on the current code, so they are kept as reproductions, not as proofs; no finding here is a high in Solidity code, so none carries a proof. Forge: forge test (forge 1.8.3, solc 0.8.28, via-IR, build ~16 min): scratch suites test/scratch/SelfDisputeFeeCapture.t.sol 2/2 and test/scratch/NoDecisionPaysDoer.t.sol 1/1 passed (demonstrations: they pass on the current code and document its behaviour); full non-fork, non-invariant suite (forge test --no-match-path 'test/fork/*' --no-match-contract Invariant): 60 suites, 395 passed, 0 failed, 2 skipped (397 total, scratch included); fork tests need an RPC and the invariant suite was excluded for time. Single summary (counted once, not repeated above) of where the earlier docs/MECHANICS.md and contracts/src disagree with the two current docs: (1) fee split 6% voters / 4% treasury (nftFeeBps 600) vs 5% NFT part / 5% staker part; (2) the YOLO fee of a YOLO reward booked to treasuryPot and the sweetener fee transferred to the treasury wallet vs 'burned by the contract directly'; (3) bonds always in IMD, max(1 IMD, 0.5 + 3%/1% of R in IMD by oracle), doubled per rejection and queued submission (up to x256) vs flat 0.5 IMD + 3%/1% in the reward's currency; (4) minimum reward $5 by oracle (0.5 IMD; none for unpriced YOLO) vs flat 5 USDC / 0.002 ETH / 1 IMD / 1,000 YOLO; (5) a $300 'large' threshold with a mandatory paid swarm check and a YOLO add-on cap at it vs 'no cap anywhere'; (6) any number of disputers, an ETH dispute fee (0.0003-0.01) with relayer reimbursement vs one disputer and 'no ETH through the contract'; (7) decision only at vote end (instantDelta unused) vs a 20-vote early close; (8) a Chainlink + v3 TWAP + v4 sample oracle for minimums, bonds, the large threshold, the sweetener cap and the trophy vs 'no oracle anywhere' and three admin parameters for the stake and trophy; (9) a tie sends 50% of the disputers' bonds to the treasury vs the whole to the winner; (10) a contributor-winner forfeits his bond share vs no such rule; (11) trophy priced by the current version's oracle with a 10,000 YOLO fallback vs the FDV parameter; (12) no stake, Predict, burner or price parameter in code; (13) ParamsRegistry owner is a single EOA with a 48 h timelock on every parameter vs instant price parameters. **Reproduction** Scratch tests: contracts/test/scratch/SelfDisputeFeeCapture.t.sol (2 tests) and contracts/test/scratch/NoDecisionPaysDoer.t.sol (1 test), run with forge test --match-path 'test/scratch/*' from contracts/. forge test (forge 1.8.3, solc 0.8.28, via-IR, build ~16 min): scratch suites test/scratch/SelfDisputeFeeCapture.t.sol 2/2 and test/scratch/NoDecisionPaysDoer.t.sol 1/1 passed (demonstrations: they pass on the current code and document its behaviour); full non-fork, non-invariant suite (forge test --no-match-path 'test/fork/*' --no-match-contract Invariant): 60 suites, 395 passed, 0 failed, 2 skipped (397 total, scratch included); fork tests need an RPC and the invariant suite was excluded for time --- Judge's submission `e82e0a5360e0c554abff5dd5fb098a92682bbfd3591a4b9b1a8414c0ae81de18`, accepted on the IdentityMD network. Acceptance means the report met the job's checks; it is not a guarantee that the code has no other defects.