THE MANUAL.

01What is uniBOT?

uniBOT is a fleet of 256 cybernetic pegasi bound to a single Uniswap v4 hook contract on Ethereum mainnet. The bots are NFTs - each one rolled fairly at mint with a model, a tier, and a power score. Owning a bot grants you a yield share of every $UBOT swap forever.

The fleet is original-design from the ground up: an autonomous swarm of cybernetic pegasi rebuilt as fleet-mounted, hook-bound trading mechs. Cute heads, stark wings, single horn forward. The contract surface is what matters - the bots are the treasury, the treasury is the fleet.

02The Fleet

Each bot has four traits, all sealed at mint:

• Model - one of 8 chassis: PEGASUS, HARRIER, CYGNET, SARACEN, ASTERIA, MEDUSA, CALYPSO, TITAN.
• Tier - DRONE / SCOUT / STRIKER / VANGUARD / OVERLOAD. Determines yield weight.
• Power - cosmetic stat in the metadata. Scales with tier band.
• Minted At - the block timestamp the bot came online.

Tier weights: DRONE 1x · SCOUT 3x · STRIKER 8x · VANGUARD 20x · OVERLOAD 50x. Roll probabilities: 60% / 25% / 10% / 4% / 1%.

03The v4 Hook

Uniswap v4 introduced hooks - contracts that get called at specific points in a pool's lifecycle. uniBOT uses two hook flags:

• AFTER_SWAP - called after every swap completes
• AFTER_SWAP_RETURNS_DELTA - lets the hook return a delta that subtracts from the swap output

Combined flag mask: 0x0044. Hook addresses must be salt-mined to land on these specific bits, which is why the project ships a HookDeployer contract.

Inside _afterSwap(), the hook reads the unspecified-side delta, computes a 5% surcharge, and calls poolManager.take() to pull that much into its own balance. The hook is also the bot collection contract - so the surcharge accumulates directly in the same place that distributes yield.

04$UBOT Token

$UBOT is a vanilla ERC-20 with two non-standard hooks for the bot system:

• burn(amount) - any holder can burn from their own balance.
• burn_from_bot_contract(amount) - only callable by the bot contract; burns from the treasury during epoch settlement.

Trading is gated by trading_open until the owner flips open_trading(). Excluded addresses (owner, marketing, dev, bot contract) can move tokens before the gate is open so liquidity can be seeded.

05Yield Math

On every swap, the hook computes:

surcharge = abs(unspecified_delta) * surcharge_bps / 10_000
poolManager.take(unspecified_currency, address(this), surcharge);
return (afterSwap.selector, int128(uint128(surcharge)));

The returned delta tells the v4 PoolManager to charge the swapper this much - so the LP curve is untouched, and the take comes off the user side.

At each 7-day epoch boundary, anybody can call distribute_to_holders() with the current holder list and weight array (typically generated off-chain by indexing Transfer events). The contract splits the treasury:

• 70% - paid out to holders, weighted by total tier-mult
• 20% - rolled forward into the next epoch
• 10% - $UBOT side burned permanently from supply

Holder amounts get added to pending_ubot[] and pending_eth[] mappings. Holders pull their share by calling claim_yield() any time after.

06Minting

Mint is open once the owner flips set_mint_open(true). Cost is 0.05 ETH per bot, max 5 per transaction, max 256 total ever.

uniBot.mint{value: 0.05 ether}(1);

The roll uses blockhash(block.number-1) + block.prevrandao + the minter's address + the new token id - which is good-enough randomness for an art mint where there's no MEV target above the floor odds.

07Claiming

Once an epoch is distributed, your pending_ubot[you] and pending_eth[you] values are non-zero. Call:

uniBot.claim_yield();

This zeroes both pending mappings and sends $UBOT + ETH to your address in one transaction. Or use the Claim page.

08Deployment

The deploy is done in this order:

• Deploy UBotToken with constructor args (supply, marketing_wallet, dev_wallet). Owner is hardcoded.
• Deploy HookDeployer (no args).
• Salt-mine via HookDeployer.mine_and_deploy() with the UniBot creation code + (poolManager, ubot_token) args. Address must satisfy addr & 0x3FFF == 0x0044.
• Call UBotToken.set_bot_contract(unibot_addr).
• Initialize the v4 pool with (WETH, UBOT, fee, tickSpacing, hooks=unibot_addr).
• Seed liquidity, then UBotToken.open_trading() + UniBot.set_mint_open(true).

09Owner Controls

The hardcoded owner address is 0xa79D8Df387AF1dB04ecC1358A1Aa4C9bfCBb39ad. Owner can:

• set_mint_open(bool) - open/close mint
• set_surcharge_bps(uint24) - adjust surcharge, capped at 10%
• set_ubot_token(address) - rebind token (only if zero arg case)
• withdraw_to(...) - emergency drain (token + dev key controlled)
• open_trading() / pause_trading() on the token
• set_limits(max_buy_bps, max_wallet_bps) - tune anti-snipe caps; default 0.5% max buy + 2% max wallet
• set_limits_active(bool) - flip all limits off (typical: leave on for first 24-48h, then disable)
• set_pool_manager(address) - rebind the v4 PoolManager (defaults to mainnet singleton)

Anti-snipe limits are skipped during pre-trading (so initial liquidity adds work) and skipped for any address marked is_excluded_from_gate (owner, marketing, dev, bot contract, pool manager). They only apply between regular wallets after trading_open = true.

Owner cannot mint bots for free, cannot change tier weights, cannot rewrite distribution math, and cannot block claims. Those are immutable.

10Risks

uniBOT is unaudited. Treat it as experimental. The main risks:

• Smart contract bugs - the hook + ERC-721 + treasury are combined into a single contract. Read the source.
• v4 mainnet maturity - Uniswap v4 is new on mainnet. Hooks have failure modes nobody has stress-tested at volume yet.
• Volume risk - yield = volume × surcharge. Low volume = low yield. There is no inflation backstop.
• Owner key - the hardcoded owner can adjust surcharge bps and pause mint. Not bot-related, but it is a trust point.

Don't put more in than you'd lose. This is a meme + a hook + a fleet. Read the code, understand the math, then decide.