Pricing recipe

Every number TAPE2 shows can be reproduced with one eth_call to the pool and a few lines of arithmetic. This page is the recipe. Nothing here needs TAPE2, a key, or an account; the pool answers anyone.

One call

The pool's observe(uint32[] secondsAgos) returns the cumulative tick at each requested time in the past. Ask for 169 times, from 7 days ago to now in hourly steps, and you have the 7-day tape in one round trip.

With Foundry's cast:

cast call 0xA70fc67C9F69da90B63a0e4C05D229954574E313 \
  "observe(uint32[])(int56[],uint160[])" \
  "[604800,601200,597600, ... ,3600,0]" \
  --rpc-url https://rpc.mainnet.chain.robinhood.com --json

The first array returned is the cumulative tick at each time, oldest first. On 2026-10-15 the call answered in 1.3 seconds.

The arithmetic

step = 3600
ticks[i]   = (cum[i+1] - cum[i]) / step              # 168 hourly average ticks
rets[i]    = (ticks[i+1] - ticks[i]) * ln(1.0001)    # 167 hourly log returns
sd         = sample standard deviation of rets
sigma      = sd * sqrt(365 * 86400 / step)           # annualized realized vol

Then, with spot S, strike K, T = 7 / 365 and r = 0:

d1 = (ln(S / K) + sigma^2 * T / 2) / (sigma * sqrt(T))
d2 = d1 - sigma * sqrt(T)
C  = S * N(d1) - K * N(d2)                            # premium, same unit as S and K

N is the standard normal CDF. For an at-the-money call S = K, so the premium as a share of spot is simply N(d1) - N(d2).

A complete script

This is the script the project used to measure the pools (_ref/vol.py). It needs Python 3 and cast on the path.

import subprocess, json, math, time
R = 'https://rpc.mainnet.chain.robinhood.com'
POOLS = {'CASHCAT': '0xA70fc67C9F69da90B63a0e4C05D229954574E313',
         'PONS':    '0x10CC6BD38112cAc182db90B6a71d8Bb5939526bA'}

def observe(pool, secs):
    arr = '[' + ','.join(str(s) for s in secs) + ']'
    out = subprocess.run(['cast', 'call', pool, 'observe(uint32[])(int56[],uint160[])', arr,
                          '--rpc-url', R, '--json'], capture_output=True, text=True)
    return [int(x) for x in json.loads(out.stdout)[0]]

def realized(pool, window, step):
    cums = observe(pool, list(range(window, -1, -step)))
    ticks = [(cums[i+1] - cums[i]) / step for i in range(len(cums) - 1)]
    rets = [(ticks[i+1] - ticks[i]) * math.log(1.0001) for i in range(len(ticks) - 1)]
    m = sum(rets) / len(rets)
    sd = math.sqrt(sum((r - m) ** 2 for r in rets) / (len(rets) - 1))
    return sd * math.sqrt(365 * 86400 / step)

def bs_call(S, K, T, sig):
    N = lambda x: 0.5 * (1 + math.erf(x / math.sqrt(2)))
    d1 = (math.log(S / K) + (sig * sig / 2) * T) / (sig * math.sqrt(T))
    d2 = d1 - sig * math.sqrt(T)
    return S * N(d1) - K * N(d2)

for name, pool in POOLS.items():
    v7 = realized(pool, 7 * 86400, 3600)
    print(name, f"7d vol {v7*100:.0f}%", f"7-day ATM call {bs_call(100, 100, 7/365, v7):.1f}% of spot")

What it printed on 2026-10-15

CASHCAT: 24h vol 152% (145 pts, 1.4s) | 7d vol 124% (169 pts, 1.3s) | 21d vol 125% (253 pts, 1.3s) | 7-day ATM call = 6.9% of spot
PONS:    24h vol 139% (145 pts, 1.2s) | 7d vol 135% (169 pts, 1.1s) | 21d vol 117% (253 pts, 1.2s) | 7-day ATM call = 7.4% of spot

Run it again and you will get today's numbers, which is the point. The site's hero and price scene run this same recipe in the browser, through the site's own relay to the same RPC.

Spot

The contract prices off the higher of two numbers: the pool's time-weighted average tick over the last 30 minutes (observe([1800, 0])), and the current tick from slot0(). Price per coin in WETH is 1.0001 ^ tick, adjusted by the two tokens' decimals and inverted if the coin is token1. Both launch pools have the coin as token0 and WETH as token1.

Windows the site shows

What the contract does with it

The contract (engine/src/Tape2.sol) runs the same arithmetic in 18-decimal fixed point (src/lib/Pricing.sol, tested against this script's output at the same block). Its quote rule, which the site's price scene mirrors exactly, is:

volLong = max(vol24h, vol7d, vol21d)        # the three cached windows, each under 12 hours old
volNow  = realized vol over the last 6 hours in 10-minute steps, read fresh
paused  = volNow > 3 * volLong              # no purchases during a storm
sigma   = max(volLong, volNow) + 0.20       # 20 points of vol on top
price   = max(TWAP over 30 minutes, spot)
premium = callPrice(price, strike, sigma, expiry - now)

So at the vols measured on 2026-10-15 (CASHCAT 24-hour 152%, 7-day 124%, 21-day 125%), the contract's sigma is 172% and a 7-day at-the-money call is about 9.5% of spot, above the 6.9% that the 7-day vol alone gives. quote(coin, strike, expiry) on the contract returns every one of these numbers, and vol(coin) returns the four windows computed fresh.

Anyone may call refresh(coin, window) to recompute a cached window; a purchase reverts with VolStale if any of the three is older than 12 hours, and with VolSpike while paused.

How it worksRisks for writers