# Why old reflections broke ## Architecture is destiny SafeMoon launched in March 2021 and within months spawned thousands of imitators. The mechanic was elegant on paper: every transfer of the token deducted a small percentage, redistributed pro-rata to existing holders. Hold the token. Receive more of it. No staking, no farming, no claim. Pure passive yield. The category briefly hit a combined market cap in the tens of billions. By late 2022 it was dead. Not because the demand evaporated — passive yield from holding remains one of the most desired mechanics in crypto — but because the architecture was incompatible with the rest of DeFi. This page walks through the four structural failures and why they could not be patched. ## Failure 1: Composability collapsed The ERC-20 standard defines `transfer(address to, uint256 amount)` as moving `amount` tokens to `to`. Most DeFi protocols treat this as a contract invariant. If you tell a Uniswap V2 pool you sent it 100 tokens, it expects to receive 100 tokens. Reflection tokens overrode `transfer()` to take a cut. If you called `transfer(pool, 100)`, the pool received 95. The pool's internal accounting now diverged from reality. Subsequent swaps would fail, prices would skew, and the pool would slowly drain. The workarounds were ugly. Some protocols required reflection tokens to whitelist the pool as fee-exempt. This required a privileged owner function. It also meant the redistribution mechanic broke for the largest holder of the token — the LP itself — which defeated the point. Most lending protocols, bridges, aggregators, and CEXes simply refused to list them. Reflection tokens became islands. ## Failure 2: Rebasing accounting broke contracts Some reflection implementations went further. Instead of taxing each transfer, they conceptually "rebased" — increasing every holder's balance silently over time. The `balanceOf()` view returned a number that grew without any on-chain transfer event firing. This broke every contract that cached balances. A lending position based on collateral balance at deposit would silently underreport. An options position would misprice. Any indexer tracking the token would desync from the on-chain state on every block. You could not safely use a rebasing reflection token as collateral, as a base asset, or as a settlement asset for anything that mattered. ## Failure 3: The tax fired on every transfer, not every trade The mechanic could not distinguish between trades and movements. Sending the token to your own cold wallet was taxed. Sending it to a friend was taxed. Approving it for use in another contract — fine, but the moment that contract pulled the tokens, the transfer was taxed. This meant the act of self-custody — the foundational principle of crypto — was penalized. Multisigs, smart accounts, treasury management, gnosis safes, even just consolidating funds across your own wallets: all incurred the tax. The fee was structurally indiscriminate. It could not look at the destination and say "this is the DEX router, charge them" because the DEX router was just another `address`. Whitelisting individual addresses was the only fix, which created the same admin-controlled tax surface that defeated the trustless premise. ## Failure 4: The team controlled the tax Because the fee logic lived inside the token contract — and because so many edge cases required admin intervention (whitelisting routers, blacklisting bots, adjusting rates for "marketing phases") — virtually every reflection token shipped with owner-controlled functions. The owner could change the fee rate. The owner could exempt specific addresses. The owner could change the destination of the redistributed tokens. The owner could pause transfers entirely. The rug surface was permanent and structural. Even the most well-intentioned teams retained the power to silently divert the redistribution to a wallet they controlled. Many did exactly that. ## How V4 hooks fix all four Uniswap V4 introduces pool-attached hook contracts that can intercept swaps via callbacks. This makes it possible to move the redistribution mechanic out of the token entirely. {% stepper %} {% step %} ### The token is vanilla. No transfer override, no tax, no rebasing. Wallet-to-wallet sends do exactly what ERC-20 says they do. Every DeFi protocol works with it normally. {% endstep %} {% step %} ### The fee fires on swaps, not transfers. Only swaps through the official pool — i.e., trades — trigger the hook. Self-custody is free. Composability is preserved. {% endstep %} {% step %} ### The hook is deployed once, ownerless. Fee rate and split are constants in the bytecode. Nobody can change them, including the deployers. {% endstep %} {% step %} ### The LP lock is enforced at the hook level. The hook's permissions prevent the LP position from being modified or withdrawn. The lock is not a separate timelock — it is a property of the architecture. {% endstep %} {% endstepper %} | Dimension | Old Reflections | TITHE (V4-Native) | | ---------------------- | ------------------------------ | --------------------------------------- | | Where the tax lives | Inside the ERC-20 `transfer()` | Inside the V4 pool hook | | What gets distributed | More of the same token | Pure ETH | | Wallet-to-wallet sends | Taxed | Untaxed | | DeFi composability | Broken in most protocols | Vanilla ERC-20, works everywhere | | Accounting model | Rebasing balances | Stable balances + claimable accumulator | | Mutability | Owner can adjust | Hook is ownerless and immutable | | LP rug surface | Manual lockers / trust | Locked at hook level | The pattern is now used by Flaunch (creator coins), Founil (donation coins), Zora's V4 creator tokens, and others. TITHE applies it to the reflection mechanic specifically — the one category that needed it most, because the failure mode in 2021 was architectural, not market-driven. --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://tithe-coin.gitbook.io/tithe-coin/why-old-reflections-broke.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.