V4Echo Protocol

V4Echo is a Uniswap V4 hook protocol where every swap on the ETH/V4ECHO pool spawns an ephemeral Ghost ERC-1155 token representing a snapshot of the pool price at that exact block. Ghosts decay over 100–1000 blocks, with the actual expiry derived from a future blockhash so that nobody — including block proposers — can predict it at mint time.

While alive, ghost holders earn a share of all swap fees that pass through their specific price range. When a ghost dies, anyone can call burnGhost() and collect 5% of its accrued fees as a bounty. There is no admin key, no upgrade proxy, no privileged role — the entire lifecycle is enforced by the hook contract.

In production, V4Echo lives as a single immutable hook contract attached to a Uniswap V4 pool on mainnet. Real users interact through any front-end (this one, an aggregator, or directly via Etherscan) and pay real gas. Here is the canonical happy path:

1. A trader sends a normal Uniswap V4 swap of ≥ 0.01 ETH for V4ECHO through their wallet (MetaMask, Rabby, Smart Wallet, etc).
2. The pool executes the swap; in the same transaction the afterSwaphook fires and mints a Ghost ERC-1155 to the trader, paying ~140k extra gas. At ~30 gwei that's roughly $8–12 in overhead, paid once.
3. For the next 50 blocks (~10 min) the ghost is non-transferable. The trader either holds it or burns it; speculation can't start yet.
4. Every subsequent swap that touches the ghost's price range increments its feeAccumulator. If the pool trends inside the snapshot range, the ghost gets fat. If price drifts away, fees go elsewhere.
5. After lockup, ghosts trade on any ERC-1155 marketplace (Reservoir, OpenSea, custom orderbook). A live secondary market on fee rights emerges.
6. Anywhere within 256 blocks of mint, anyone can call commitExpiry() to lock in blockhash(birthBlock + 64). After this the death block is public and ghost prices reprice instantly.
7. Once block.number > expiryBlock, transfers freeze. burnGhost() is callable by anyone — bots will race for the 5% bounty within the first block. The last recorded holder receives 95% of accumulated fees.

Because every step is permissionless and triggered by economic incentive, V4Echo does not need a backend, a keeper network, or even a website. The front-ends are convenience layers; the protocol runs on its own.

For honest illustration, assume a mainnet pool with $2M TVL and $5M daily swap volume on a 0.30% fee tier. That's $15,000/day in pool fees, of which 5% ($750/day) flows to ghost holders proportional to range overlap.

Ghosts whose price range matches the actual trading band become disproportionately valuable. A trader who correctly predicts a tight 50bps range during a volatile session can capture 10–50× the average ghost yield. This is the core speculation surface V4Echo creates that vanilla Uniswap does not.

Sustainability check: burn bounties at $0.02–$0.20 per ghost are below mainnet gas at 30 gwei (~$2 per burnGhost call), so burns will batch via Multicall or run only on cheaper chains (Arbitrum, Base). On Base at ~0.05 gwei a burn costs ~$0.003, making the bounty profitable from $0.05 of accrued fees and up.

Price-Snapshot Ghosts. Every swap mints a Ghost NFT tied to the exact sqrtPrice at swap time, creating a live "fee futures" market. Traders speculate on which price levels will attract the most volume.

• Ghost holders earn fees only from swaps touching their specific price range.
• 50-block transfer lockup prevents immediate flip — creates short-term commitment.
• burnGhost() bounty of 5% incentivizes permissionless cleanup without any admin key.
• Price manipulation is self-defeating: pumping price destroys fee income from existing ghosts the manipulator holds.
• Expiry uses blockhash(birthBlock + 64) — unknowable at mint, unpredictable even to block proposers.

1. User swaps ETH → V4ECHO on the Uniswap V4 host pool.
2. The afterSwap hook mints a Ghost ERC-1155 with { sqrtPrice, birthBlock, feeAccumulatorPointer }.
3. Ghost is non-transferable for 50 blocks. Secondary ghost markets emerge after lockup.
4. All subsequent swaps touching the ghost's price range atomically increment its feeAccumulator.
5. Expiry = blockhash(birthBlock + 64). Anyone calls commitExpiry() within 256 blocks to lock it in.
6. Post-expiry: transfers freeze. burnGhost() distributes 5% to caller, 95% to last holder.

function afterSwap(
    address sender,
    PoolKey calldata key,
    SwapParams calldata params,
    BalanceDelta delta,
    bytes calldata
) external override returns (bytes4, int128) {
    if (absEth(delta) < MIN_SWAP) return (Hooks.AFTER_SWAP_SELECTOR, 0);

    uint160 sqrtPrice = StateLibrary.getSqrtPriceX96(poolManager, key.toId());
    uint256 ghostId = nextGhostId++;

    ghosts[ghostId] = Ghost({
        sqrtPrice:        sqrtPrice,
        rangeWidth:       deriveRange(params),
        birthBlock:       uint64(block.number),
        expiryBlock:      0,                  // set later by commitExpiry()
        feeAccumulator:   0,
        lastHolder:       sender
    });
    _mint(sender, ghostId, 1, "");

    emit GhostSpawned(ghostId, sender, sqrtPrice);
    return (Hooks.AFTER_SWAP_SELECTOR, 0);
}

The following constants are hardcoded into the hook at deployment. Governance can only adjust ranges marked with †.

V4Echo ships as three contracts: the hook (immutable), the V4ECHO ERC-20 (mintable only by the deployer once at genesis), and a staking vault (also immutable, holding fee distribution logic for the 5% staker cut).

# 1. Deploy V4ECHO ERC-20 with full supply minted to deployer
forge create src/V4Echo.sol:V4Echo \
  --rpc-url $RPC --private-key $KEY

# 2. CREATE2 the hook at the address required by Uniswap V4 hook flags
forge script script/DeployHook.s.sol:DeployHook \
  --rpc-url $RPC --broadcast

# 3. Initialize the ETH/V4ECHO pool with the hook attached
cast send $POOL_MANAGER 'initialize(...)' --rpc-url $RPC

# 4. Renounce ownership on V4Echo ERC-20
cast send $V4ECHO 'renounceOwnership()' --rpc-url $RPC

After step 4 the protocol has no owner. The only governance surface remaining is V4ECHO holder voting on EXPIRY_MIN / EXPIRY_MAX via a separate Governor contract that holds the parameter pointer.