Documentation

Summary

TALUS is a token on Robinhood Chain paired against WETH in a Uniswap v3 pool. Fees accumulate in the protocol as WETH. A permissionless function converts them: 70% becomes a single-sided v3 position placed under the price and locked at the moment it is minted, 20% is streamed to stakers in WETH, and 10% buys TALUS on the market and destroys it.

Nothing in the protocol has an owner. There is no multisig, no timelock, no pause, no upgrade path and no setter of any kind. The split is written as compile-time constants.

The problem

Market cap is a multiplication. Pool depth is what settles a sale, and only the quote side of a pool does it. Half of the number on the screen is the asset the seller is trying to get out of, which is why the last person out gets a different price from the first.

The usual failure is not exotic. Volume climbs, price climbs, and the pool stays exactly the size it was seeded at. The first real exit makes the price give, and the rush that follows finishes it. Meanwhile the creator fees are real, they are being generated the whole time, and they are going to a wallet.

The split

Fees arrive as WETH. They leave in three directions, in these proportions:

FLOOR_BPS     7000   70.0%   under the price, permanently
STAKERS_BPS   2000   20.0%   to whoever staked
BURN_BPS      1000   10.0%   bought and destroyed
KEEPER_BPS      50    0.5%   to whoever made the call

The keeper’s 0.5% comes off the top; the three shares are taken from what remains. Every one of these is a constant in the contract. There is no function anywhere in the codebase that writes to them, and no address privileged enough to try.

deepen()

deepen() is the only action the protocol has, and anyone can call it. The caller is paid 0.5% of the amount converted, out of that amount, so the keeper funds itself and there is nobody in particular who has to show up.

Conditions, checked on chain

  • Accumulated balance ≥ 0.25 ETH. Below that the conversion is mostly gas.
  • Reference price is the pool’s own 30-minute TWAP, read from the v3 oracle. Never spot.
  • Spot must sit within 5% of that TWAP, which is 487 ticks, since 1.0001^487 ≈ 1.05. If they disagree, the call reverts and the fees stay where they are.
  • The new band’s upper bound must be at or above the highest one ever placed. That is the ratchet.

A call that fails any of these reverts. There is no branch in which the contract converts anyway on a price it does not trust.

The position

Each call mints one Uniswap v3 position: single-sided, 100% WETH, in a range that sits entirely below the average price. In v3 a range below spot holds only the quote asset, which is exactly what a bid is.

tickUpper = twap - 834     1.0001^-834  ≈ 0.92   →   8% below
tickLower = twap - 2231    1.0001^-2231 ≈ 0.80   →  20% below

Both bounds are then snapped down to the pool’s tick spacing, so the realised band is that one or slightly wider on the far side. It is a wall of bids in a defined range, not a full-range pool spread across every price that will never print.

This is also why TALUS must sort below WETH as an address: it has to be token0 for a range under spot to hold pure WETH. The engine’s constructor refuses to deploy against a pool where that is not true.

The ratchet

A new position can be minted only if its upper bound is greater than or equal to the highest bound already placed. If the price has fallen since the last conversion, the call reverts and the contract waits, holding the fees, until the market comes back to where the floor already is.

The floor never follows the price down. That is the whole of the rule.

The lock

The position is minted with the vault as its recipient. What keeps it there is not a flag, a guard or a promise. It is the surface of that contract. FloorVault has no decreaseLiquidity, no burn, no transferFrom, no approve, no setApprovalForAll, no delegatecall, no upgrade path and no owner.

A Uniswap v3 position can be reduced only by its owner or by an approved operator. The vault can be neither, because it has no code that could act as either. The deployer has exactly the same access to it as a stranger: none.

collect() stays open and is permissionless, because collecting is the one action that cannot reduce a position: it sweeps accrued fees and nothing else. Those fees come back in two currencies, and they are routed rather than banked: the TALUS side goes straight to the dead address, the WETH side goes back to the engine and re-enters the same split.

When it is hit

When the price falls into a band, the position buys. That is what the WETH is there for. The tokens it takes in become principal inside a position no address can reduce, and they stay there. The interface reports them separately, as locked rather than burned, because that is what they are.

The tokens the protocol burns are the 10% slice, bought on the open market and sent to 0x…dEaD, plus whatever TALUS is collected as fees from the locked positions. Supply falls, and with a smaller supply standing above the same WETH, the floor per token is higher after a fall than it was before.

Staking

A single-asset position. Stake bare TALUS, receive 20% of protocol fees in WETH. No LP to build, no second leg to source, no impermanent loss, no lockup. The stake can be withdrawn in any block, and the accrued WETH comes with it.

Each conversion’s slice is not dropped in a lump: it is spread linearly over the following seven days, and any unvested part of a previous drip is folded into the new rate. Between two conversions the balance keeps climbing every second.

WETH that arrives while nothing is staked is not lost and not returned. It waits in the contract and starts dripping on the first stake.

The yield is a share of real volume, not emissions. It is not fixed and nothing about it is guaranteed. No APY is displayed anywhere on this site.

The token

  • Supply 1,000,000,000, fixed. There is no mint function.
  • Zero team allocation. No presale, no whitelist, no private round.
  • No tax, no owner, no pause, no blacklist, no upgrade path. A plain ERC-20.
  • The site is live the day of the launch.

The numbers

One central counter: the WETH waiting under the price, summed live across every locked position. One direction. It falls only when the market takes it, by buying TALUS.

Next to it: the distance from the top of the floor to spot in percent, the total burned, and the list of positions with their tick ranges, each checkable against the pool itself. No APY, ever.

The oracle

A freshly created v3 pool stores one observation, and a 30-minute lookback on it reverts. Deployment calls increaseObservationCardinalityNext so the pool can hold a window, and deepen() stays uncallable until the pool actually has 30 minutes of history behind it.

deepenBlockedBy() returns, in words, which condition is currently in the way: the threshold, the dislocation, the ratchet, or the oracle’s age. The console reads it directly.

Limits and risks

  • The price can go below the floor. Depth is finite and a large enough seller goes through it. The claim is not that the floor cannot be crossed. It is that it is irrevocable and rising.
  • The fees have to exist. Everything here is downstream of volume. No volume, no conversions, no floor growth, no staking rewards.
  • Locked means locked in both directions. WETH placed under the price cannot be recovered by anyone, including in a scenario where recovering it would be the sensible thing to do.
  • The contracts have not been audited by a third party. No audited language is used anywhere until an external review is finished.
  • Nothing here is a promise of return.

What this replaces

The usual way to spend creator fees is to push them into full-range liquidity that stays withdrawable, under a split someone can change later. Three decisions, and TALUS makes the opposite call on all three: v3 single-sided below spot rather than full range, withdrawal destroyed at the mint rather than left open, and a split written as constants rather than set by an owner.

Open the console →