TRANCHER token

• No admin mint, ever. The token has exactly one minter (the emission module), wired once, with the setter burned to the zero address. Nobody, not the deployer and not an owner, can mint by hand. Supply is a pure function of usage.
• Deterministic emission. Emission halves every epoch of cumulative USD volume. There is no time input, no admin rate, and no discretion, so distribution is mechanical and auditable rather than a managed giveaway.
• Hands-off fee support. The fee recycler is permissionless — anyone can trigger it once accrued fees cross an immutable threshold. No privileged keeper sits in the value loop.

Trading is live today. Everything token-side hangs off two optional, rebindable pointers on the trading hook. When the emission sink is bound, each fill reports usage; the emission module values it and mints; protocol fees recycle into protocol-owned liquidity underneath.

Each fill crosses the emissionSink boundary as onVolume(lp, bought, amount): the LP credited, the currency produced, and the raw token amount. The hook holds no oracle, so it reports raw numbers; the emission module is what values that volume in USD.

The module meters cumulative USD volume. The rate emitPerUsd halves every EPOCH_VOLUME of cumulative volume, so total supply is bounded by a geometric series and the schedule is fully mechanical with no cap to manage. Reward for a given dollar of volume is the emit rate at the epoch that dollar lands in:

epoch(cumVol) = cumVol / EPOCH_VOLUME          // halving index
emitPerUsd    = INITIAL_EMIT_PER_USD >> epoch  // 0 once epoch ≥ 256 → emission ends

total supply ≈ INITIAL_EMIT_PER_USD × EPOCH_VOLUME × 2   (geometric bound)

Nothing is minted until an LP claims it — emission is a lazy mint, so uncollected rewards cost no gas and bloat no supply. The halving curve over cumulative volume:

In v1 the credited party is the LP whose rung filled — liquidity is the usage being rewarded. Lending-side usage (suppliers and borrowers earning TRANCHER) is a later addition that needs no trading redeploy, because the lending hub calls the same emission module.

The hook already takes a contract-capped protocol fee on swap fees, never on principal. That quote-side fee (USDC or ETH) accrues to the recycler. Once the balance crosses an immutable threshold, anyone can call the sweep, which deploys the accrued fees into protocol-owned TRANCHER liquidity through a ladder placer. The result is standing buy-support for the token, funded entirely by real protocol usage rather than by selling tokens.

Emission halves as cumulative volume grows, while recycled fee value scales with volume. Those two curves are designed to cross. Early on, emitted token value exceeds recycled fees, which bootstraps usage. As emission halves toward zero and volume compounds, recycled fees overtake emissions. That crossover is the self-funding milestone: the point where cumulative fee value directed at the token surpasses the cumulative value of tokens emitted.

This is an emergent property of the parameters, not a hard-coded promise. There is no coded buyback and no in-contract yield guarantee. The crossover is a measurable consequence of the emission schedule and fee split, which is deliberate for the regulatory posture below.

The trading hook is live and final. The token economy attaches through a dormant, rebindable emissionSinkpointer that already shipped — the same two-step rebind pattern as lending's collateral manager. It is oracle-free: the hook just fires an onVolume callback and the module does the valuation.

proposeEmissionSink(module)  →  module.acceptEmissionSink()   // 2-step, owner-gated
proposeEmissionSink(0)                                        // one-step detach

• Today — the sink is unset, so the hook does zero emission work. Pure trading, zero overhead.
• At token launch — deploy the token, emission module, and recycler, then bind emission as the sink. Every fill starts metering usage with no trading redeploy.
• Later — lending can feed emissions the same modular way, and the entire token design can be swapped by rebinding a new module. Still no redeploy.

A buggy or greedy emission module can never brick a swap: the hook wraps the callback in try/catch, so emission is a side-effect, never a dependency of the trade settling.

These parameters set supply scale and how fast the system reaches self-funding. They are set once at deploy and are not owner-tunable afterward.

The architecture is built to minimize discretionary surface. The design choices that keep it that way:

• Mint authority ends at a non-human address — a burned setter or a timelock, never an EOA. The emission module is the sole minter.
• No discretionary distribution — emission is a pure function of metered volume. There is no allocate button and no team-controlled faucet.
• No in-contract promise of profit — the self-funding crossover is emergent, not a coded buyback or yield, and is not marketed as a guaranteed return.
• Permissionless mechanics — the recycler sweep and the emission claim are callable by anyone, with no privileged operator in the loop.
• Immutable where possible — epoch params and thresholds are set at deploy, not owner-tunable, so there is no knob to turn after launch.

These are engineering guardrails to support a hands-off posture, not legal advice. Get counsel before any public token launch.