Queries

Home

near-market

NEAR market and network state

NEAR's latest price, market cap, rank, FDV, circulating supply and 1-year price change, with the latest network state: total supply, max issuance rate, gas price, protocol version, block-producer seats and minimum stake ratio.

Run CSV

SELECT c.price_usd, c.market_cap_usd, c.rank, c.fdv_usd, c.circulating_supply, c.change_1y / 100 AS change_1y, c.fetched_at AS market_at,
  n.total_supply_near, n.max_inflation_rate, n.gas_price_yocto, n.protocol_version, n.block_producer_seats, n.minimum_stake_ratio,
  n.fetched_at AS network_at
FROM coins_latest c, network_latest n
WHERE c.coin_id = 'near'

Filled by: CoinGecko GET /coins/markets (price, market cap, FDV, rank); NEAR RPC EXPERIMENTAL_protocol_config; NEAR RPC block (finality final)
Run it yourself: npm run query -- near-market
Shown on: Home

near-price

NEAR price

NEAR's daily price in USD, each day's 00:00 UTC price except today's live one; the change over 12 months is the newest price against the price 365 days earlier.

Run CSV

SELECT day, value AS price_usd
FROM daily_series
WHERE series = 'near_price_usd'
ORDER BY day DESC

Filled by: CoinGecko GET /coins/near/market_chart?days=365 (daily price); CoinGecko GET /coins/markets (price, market cap, FDV, rank)
Calculated further in: src/lib/metrics.ts · levelChange
Run it yourself: npm run query -- near-price
Shown on: Home

Usage

intents-volume

NEAR Intents volume, 30-day totals

Daily NEAR Intents swap volume, public and confidential (Dune's value on each day it has one, DefiLlama's otherwise), with its 30-day running total; the chart takes every 30th total back from the data-through day.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series))
SELECT d.day, d.value AS volume_usd,
  SUM(d.value) OVER (ORDER BY julianday(d.day) RANGE BETWEEN 29 PRECEDING AND CURRENT ROW) AS volume_30d_usd
FROM daily_series d, through t
WHERE d.series = 'intents_volume_usd' AND d.day <= t.day
ORDER BY d.day DESC

Filled by: Dune near/near-intents query 5179085 "NEAR Intents - All-time Volume" (daily volume, public and confidential, latest run); DefiLlama GET /summary/dexs/near-intents (daily volume)
Calculated further in: src/ingest/jobs/merge-intents.ts · mergeIntentsFlows; src/lib/metrics.ts · rollingWindows
Run it yourself: npm run query -- intents-volume
Shown on: Usage

intents-confidential

Public and confidential NEAR Intents volume

Daily NEAR Intents volume split into public and confidential swaps, with the confidential share, from the NEAR team's Dune dashboard.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), dune_through AS (
  SELECT CASE WHEN COUNT(day) = 3 THEN MIN(day) END AS day FROM (
    SELECT day FROM through
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_swaps'
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_confidential_volume_usd'))
SELECT p.day, volume_usd, volume_usd - confidential_usd AS public_usd, confidential_usd, confidential_usd / volume_usd AS confidential_share
FROM (SELECT day,
    MAX(CASE WHEN series = 'dune_intents_volume_usd' THEN value END) AS volume_usd,
    MAX(CASE WHEN series = 'intents_confidential_volume_usd' THEN value END) AS confidential_usd
  FROM daily_series
  WHERE series IN ('dune_intents_volume_usd', 'intents_confidential_volume_usd')
  GROUP BY day) p, dune_through e
WHERE volume_usd > 0 AND confidential_usd IS NOT NULL AND p.day <= e.day
ORDER BY p.day DESC

Filled by: Dune near/near-intents query 5179085 "NEAR Intents - All-time Volume" (daily volume, public and confidential, latest run)
Calculated further in: src/lib/metrics.ts · rollingWindows (7-day blocks)
Run it yourself: npm run query -- intents-confidential
Shown on: Usage

intents-tvl

Funds held in NEAR Intents

NEAR Intents TVL by day, split into public and confidential balances, from the NEAR team's Dune dashboard; confidential balances count as zero before they began, as the chart draws them.

Run CSV

WITH first_confidential AS (SELECT MIN(day) AS day FROM daily_series WHERE series = 'intents_confidential_tvl_usd'),
split AS (
  SELECT p.day, p.tvl_usd, CASE WHEN p.confidential_usd IS NULL AND (f.day IS NULL OR p.day < f.day) THEN 0 ELSE p.confidential_usd END AS confidential_usd
  FROM (SELECT day,
    MAX(CASE WHEN series = 'intents_tvl_usd' THEN value END) AS tvl_usd,
    MAX(CASE WHEN series = 'intents_confidential_tvl_usd' THEN value END) AS confidential_usd
  FROM daily_series
  WHERE series IN ('intents_tvl_usd', 'intents_confidential_tvl_usd')
  GROUP BY day) p, first_confidential f)
SELECT day, tvl_usd, tvl_usd - confidential_usd AS public_usd, confidential_usd, confidential_usd / tvl_usd AS confidential_share
FROM split
WHERE tvl_usd > 0 AND confidential_usd IS NOT NULL
ORDER BY day DESC

Filled by: Dune near/near-intents query 7586891 "NEAR Intents - TVL" (daily TVL, public and confidential, latest run)
Run it yourself: npm run query -- intents-tvl
Shown on: Usage

intents-txn-share

Transactions of intents.near against every NEAR transaction, by day.

Run CSV

SELECT day, intents_txns, all_txns, 1.0 * intents_txns / all_txns AS share
FROM (SELECT day,
    MAX(CASE WHEN series = 'intents_txns' THEN value END) AS intents_txns,
    MAX(CASE WHEN series = 'near_txns' THEN value END) AS all_txns
  FROM daily_series
  WHERE series IN ('intents_txns', 'near_txns')
  GROUP BY day)
WHERE intents_txns IS NOT NULL AND all_txns > 0
ORDER BY day DESC

Filled by: NearBlocks GET /v3/accounts/intents.near/stats/txns; NearBlocks GET /v3/txn-stats, /v3/block-stats and /v3/address-stats (daily, last 365 days; older days from GET /v1/charts)
Calculated further in: src/lib/metrics.ts · ratioByDay
Run it yourself: npm run query -- intents-txn-share
Shown on: Usage

intents-dex-share

DefiLlama's Intents volume against the volume of every DEX DefiLlama tracks on NEAR (Intents included), over the 30 and 180 days to the data-through day and by calendar month through that day; both from DefiLlama, so they count the same swaps.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), windows(days) AS (VALUES (30), (180))
SELECT 'last ' || w.days || ' days' AS month, COUNT(*) AS days,
  SUM(intents_usd) AS intents_volume_usd, SUM(dex_usd) AS dex_volume_usd, SUM(intents_usd) / SUM(dex_usd) AS share
FROM windows w, (SELECT day,
    MAX(CASE WHEN series = 'defillama_intents_volume_usd' THEN value END) AS intents_usd,
    MAX(CASE WHEN series = 'near_dex_volume_usd' THEN value END) AS dex_usd
  FROM daily_series
  WHERE series IN ('defillama_intents_volume_usd', 'near_dex_volume_usd')
  GROUP BY day) p, through t
WHERE intents_usd IS NOT NULL AND dex_usd IS NOT NULL AND p.day > date(t.day, '-' || w.days || ' days') AND p.day <= t.day
GROUP BY w.days
UNION ALL
SELECT substr(p.day, 1, 7) AS month, COUNT(*) AS days,
  SUM(intents_usd) AS intents_volume_usd, SUM(dex_usd) AS dex_volume_usd, SUM(intents_usd) / SUM(dex_usd) AS share
FROM (SELECT day,
    MAX(CASE WHEN series = 'defillama_intents_volume_usd' THEN value END) AS intents_usd,
    MAX(CASE WHEN series = 'near_dex_volume_usd' THEN value END) AS dex_usd
  FROM daily_series
  WHERE series IN ('defillama_intents_volume_usd', 'near_dex_volume_usd')
  GROUP BY day) p, through t
WHERE intents_usd IS NOT NULL AND dex_usd IS NOT NULL AND p.day <= t.day
GROUP BY month
ORDER BY month DESC

Filled by: DefiLlama GET /summary/dexs/near-intents (daily volume); DefiLlama GET /overview/dexs/near
Run it yourself: npm run query -- intents-dex-share
Shown on: Usage

lead-lag-weekly

Lead-lag test inputs

The weekly inputs of the lead-lag test: 7-day blocks ending on the data-through day, with Intents volume summed, prices at the close of the block's last day (the next day's 00:00 UTC price) and active accounts averaged. The test starts at the first week with at least $25M of Intents volume, so earlier rows are shown but not tested.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)),
days AS (
  SELECT series, day, value, through_day, CAST((julianday(through_day) - julianday(day)) / 7 AS INTEGER) AS weeks_back
  FROM (
    SELECT d.series, d.value, t.day AS through_day,
      CASE WHEN d.series IN ('near_price_history_usd', 'btc_price_usd', 'eth_price_usd') THEN date(d.day, '-1 day') ELSE d.day END AS day
    FROM daily_series d, through t
    WHERE d.series IN ('intents_volume_usd', 'near_price_history_usd', 'btc_price_usd', 'eth_price_usd', 'near_active_accounts'))
  WHERE day <= through_day)
SELECT date(MAX(through_day), '-' || (weeks_back * 7) || ' days') AS week_end,
  SUM(CASE WHEN series = 'intents_volume_usd' THEN value END) AS intents_volume_usd,
  COUNT(CASE WHEN series = 'intents_volume_usd' THEN 1 END) AS volume_days,
  MAX(CASE WHEN series = 'near_price_history_usd' AND day = date(through_day, '-' || (weeks_back * 7) || ' days') THEN value END) AS near_price_usd,
  MAX(CASE WHEN series = 'btc_price_usd' AND day = date(through_day, '-' || (weeks_back * 7) || ' days') THEN value END) AS btc_price_usd,
  MAX(CASE WHEN series = 'eth_price_usd' AND day = date(through_day, '-' || (weeks_back * 7) || ' days') THEN value END) AS eth_price_usd,
  AVG(CASE WHEN series = 'near_active_accounts' THEN value END) AS active_accounts_avg
FROM days
GROUP BY weeks_back
HAVING volume_days = 7
ORDER BY week_end DESC

Filled by: Dune near/near-intents query 5179085 "NEAR Intents - All-time Volume" (daily volume, public and confidential, latest run); DefiLlama GET /summary/dexs/near-intents (daily volume); DefiLlama GET coins.llama.fi/chart/coingecko:{near,bitcoin,ethereum} (daily); NearBlocks GET /v1/charts (daily active and new accounts)
Calculated further in: src/lib/lead-lag.ts · runLeadLag (log changes, market fit, lagged correlations, block-bootstrap p-values, Holm)
Run it yourself: npm run query -- lead-lag-weekly
Shown on: Usage

chain-activity

Transactions and active, relayed and new accounts per day

Daily NEAR transactions and the share a relayer signed for another account, accounts that signed a transaction, accounts that acted through a relayer, and new accounts.

Run CSV

SELECT day, txns, relayed_txns, 1.0 * relayed_txns / txns AS relayed_share, active_accounts, relayed_accounts, new_accounts
FROM (SELECT day,
    MAX(CASE WHEN series = 'near_txns' THEN value END) AS txns,
    MAX(CASE WHEN series = 'near_relayed_txns' THEN value END) AS relayed_txns,
    MAX(CASE WHEN series = 'near_active_accounts' THEN value END) AS active_accounts,
    MAX(CASE WHEN series = 'near_relayed_accounts' THEN value END) AS relayed_accounts,
    MAX(CASE WHEN series = 'near_new_accounts' THEN value END) AS new_accounts
  FROM daily_series
  WHERE series IN ('near_txns', 'near_relayed_txns', 'near_active_accounts', 'near_relayed_accounts', 'near_new_accounts')
  GROUP BY day)
ORDER BY day DESC

Filled by: NearBlocks GET /v3/txn-stats, /v3/block-stats and /v3/address-stats (daily, last 365 days; older days from GET /v1/charts); NearBlocks GET /v1/charts (daily active and new accounts)
Run it yourself: npm run query -- chain-activity
Shown on: Usage

chain-activity-yoy

Chain activity against a year earlier

Transactions and new accounts, and the median daily active accounts, over the 30 days to the newest day all three NearBlocks series have, against the same 30 days a year earlier; with the share of transactions a relayer signed and the median daily accounts that acted through a relayer over the same days. A median needs all 30 days stored, so a window that is not fully stored shows none.

Run CSV

WITH last AS (
  SELECT CASE WHEN COUNT(*) = 3 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('near_txns', 'near_active_accounts', 'near_new_accounts') GROUP BY series)),
windows(name, end_day) AS (
  SELECT 'last 30 days', day FROM last UNION ALL SELECT 'same 30 days a year earlier', date(day, '-365 days') FROM last),
window_days AS (
  SELECT w.name, w.end_day, d.series, d.value,
    ROW_NUMBER() OVER (PARTITION BY w.name, d.series ORDER BY d.value) AS value_rank,
    COUNT(*) OVER (PARTITION BY w.name, d.series) AS series_days
  FROM windows w
  JOIN daily_series d ON d.series IN ('near_txns', 'near_relayed_txns', 'near_active_accounts', 'near_new_accounts', 'near_relayed_accounts')
    AND d.day > date(w.end_day, '-30 days') AND d.day <= w.end_day)
SELECT name, end_day,
  SUM(CASE WHEN series = 'near_txns' THEN value END) AS txns,
  COUNT(CASE WHEN series = 'near_txns' THEN 1 END) AS txn_days,
  CASE WHEN COUNT(CASE WHEN series = 'near_relayed_txns' THEN 1 END) = 30
    THEN SUM(CASE WHEN series = 'near_relayed_txns' THEN value END) / SUM(CASE WHEN series = 'near_txns' THEN value END) END AS relayed_share,
  COUNT(CASE WHEN series = 'near_relayed_txns' THEN 1 END) AS relayed_txn_days,
  CASE WHEN COUNT(CASE WHEN series = 'near_active_accounts' THEN 1 END) = 30
    THEN AVG(CASE WHEN series = 'near_active_accounts' AND value_rank IN ((series_days + 1) / 2, (series_days + 2) / 2) THEN value END) END AS median_active_accounts,
  COUNT(CASE WHEN series = 'near_active_accounts' THEN 1 END) AS active_account_days,
  SUM(CASE WHEN series = 'near_new_accounts' THEN value END) AS new_accounts,
  COUNT(CASE WHEN series = 'near_new_accounts' THEN 1 END) AS new_account_days,
  CASE WHEN COUNT(CASE WHEN series = 'near_relayed_accounts' THEN 1 END) = 30
    THEN AVG(CASE WHEN series = 'near_relayed_accounts' AND value_rank IN ((series_days + 1) / 2, (series_days + 2) / 2) THEN value END) END AS median_relayed_accounts,
  COUNT(CASE WHEN series = 'near_relayed_accounts' THEN 1 END) AS relayed_account_days
FROM window_days
GROUP BY name, end_day
ORDER BY end_day DESC

Filled by: NearBlocks GET /v3/txn-stats, /v3/block-stats and /v3/address-stats (daily, last 365 days; older days from GET /v1/charts); NearBlocks GET /v1/charts (daily active and new accounts)
Calculated further in: src/data/thesis-metrics/activity.ts · flowYoY, windowMedian
Run it yourself: npm run query -- chain-activity-yoy
Shown on: Usage

intents-swaps

NEAR Intents swaps per day

NEAR Intents swaps per day, public and confidential, with that day's volume and the average swap size (volume ÷ swaps), from the NEAR team's Dune dashboard.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), dune_through AS (
  SELECT CASE WHEN COUNT(day) = 3 THEN MIN(day) END AS day FROM (
    SELECT day FROM through
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_swaps'
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_confidential_volume_usd'))
SELECT p.day, swaps, volume_usd, volume_usd / swaps AS avg_swap_usd
FROM (SELECT day,
    MAX(CASE WHEN series = 'intents_swaps' THEN value END) AS swaps,
    MAX(CASE WHEN series = 'dune_intents_volume_usd' THEN value END) AS volume_usd
  FROM daily_series
  WHERE series IN ('intents_swaps', 'dune_intents_volume_usd')
  GROUP BY day) p, dune_through e
WHERE swaps > 0 AND p.day <= e.day
ORDER BY p.day DESC

Filled by: Dune near/near-intents query 4374089 "NEAR Intents - Activity" (daily swaps, latest run); Dune near/near-intents query 5179085 "NEAR Intents - All-time Volume" (daily volume, public and confidential, latest run)
Calculated further in: src/data/thesis-metrics/intents.ts · intentsMetrics (sumWindow, coversWindow)
Run it yourself: npm run query -- intents-swaps
Shown on: Usage

intents-chain-mix

NEAR Intents volume by chain

NEAR Intents volume, public and confidential, over the 30 days to the newest stored day, by the chain each swap is counted under, with each chain's share; no rows unless all 30 days are stored.

Run CSV

WITH last AS (SELECT MAX(day) AS day FROM intents_chain_daily),
recent AS (
  SELECT chain, volume_usd FROM intents_chain_daily, last
  WHERE intents_chain_daily.day > date(last.day, '-30 days') AND intents_chain_daily.day <= last.day
    AND (SELECT COUNT(DISTINCT d.day) FROM intents_chain_daily d WHERE d.day > date(last.day, '-30 days') AND d.day <= last.day) = 30)
SELECT chain, SUM(volume_usd) AS volume_usd, SUM(volume_usd) / (SELECT SUM(volume_usd) FROM recent) AS share
FROM recent
GROUP BY chain
HAVING SUM(volume_usd) > 0
ORDER BY volume_usd DESC

Filled by: Dune near/near-intents query 5157565 "NEAR Intents - Blockchain Volume" (daily volume by chain, latest run)
Run it yourself: npm run query -- intents-chain-mix
Shown on: Usage

intents-stablecoin-share

NEAR Intents volume per day and the part counted under stablecoin symbols, with its share, from the volume by token on the NEAR team's Dune dashboard.

Run CSV

SELECT day, SUM(volume_usd) AS volume_usd,
  SUM(CASE WHEN UPPER(symbol) IN ('USDC', 'USDCX', 'USDT', 'USDT0', 'USD₮0', 'DAI', 'XDAI', 'USDF', 'USDG', 'USD1', 'USDE', 'USDS', 'FDUSD', 'PYUSD', 'RLUSD', 'FRAX', 'TUSD', 'GHO', 'USDD', 'CRVUSD', 'EURC', 'EURE', 'GBPE') THEN volume_usd ELSE 0 END) AS stablecoin_usd,
  SUM(CASE WHEN UPPER(symbol) IN ('USDC', 'USDCX', 'USDT', 'USDT0', 'USD₮0', 'DAI', 'XDAI', 'USDF', 'USDG', 'USD1', 'USDE', 'USDS', 'FDUSD', 'PYUSD', 'RLUSD', 'FRAX', 'TUSD', 'GHO', 'USDD', 'CRVUSD', 'EURC', 'EURE', 'GBPE') THEN volume_usd ELSE 0 END) / SUM(volume_usd) AS stablecoin_share
FROM intents_symbol_daily
GROUP BY day
ORDER BY day DESC

Filled by: Dune near/near-intents query 5157527 "NEAR Intents - Token Volume" (daily volume by token, latest run)
Calculated further in: src/lib/metrics.ts · rollingWindows (7-day blocks)
Run it yourself: npm run query -- intents-stablecoin-share
Shown on: Usage

tvl-stablecoins

DeFi TVL and stablecoins on NEAR

DeFi TVL and USD-pegged stablecoins on NEAR, daily.

Run CSV

SELECT day, tvl_usd, stablecoins_usd
FROM (SELECT day,
    MAX(CASE WHEN series = 'near_tvl_usd' THEN value END) AS tvl_usd,
    MAX(CASE WHEN series = 'near_stablecoins_usd' THEN value END) AS stablecoins_usd
  FROM daily_series
  WHERE series IN ('near_tvl_usd', 'near_stablecoins_usd')
  GROUP BY day)
ORDER BY day DESC

Filled by: DefiLlama GET /v2/historicalChainTvl/Near; DefiLlama GET stablecoins.llama.fi/stablecoincharts/Near
Run it yourself: npm run query -- tvl-stablecoins
Shown on: Usage

Revenue

fee-chain-30d

From NEAR Intents volume to NEAR bought, 30 days

NEAR Intents volume, gross fees, NEAR Intents revenue (the share the app operators keep), buyback dollars and the NEAR bought over the 30 days to the fee windows' last day (the data-through day, or the last day of fees and revenue when earlier, since the newest day of fees is still filling), with each step's share. The last column is the NEAR bought a year at that pace as a share of circulating NEAR (market cap ÷ price).

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), fees_through AS (
  SELECT CASE WHEN COUNT(day) = 3 THEN MIN(day) END AS day FROM (
    SELECT day FROM through
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_fees_usd'
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_revenue_usd')), flows AS (
  SELECT day, volume_usd, fees_usd, revenue_usd, buybacks_usd, price_usd,
    buybacks_usd / price_usd AS bought_near, revenue_usd / price_usd AS revenue_near
  FROM (SELECT p.day, p.volume_usd, p.fees_usd, p.revenue_usd, p.buybacks_usd, COALESCE(p.price_usd, (SELECT h.value FROM daily_series h WHERE h.series = 'near_price_history_usd' AND h.day = p.day
      AND h.day < (SELECT MIN(day) FROM daily_series WHERE series = 'near_price_usd'))) AS price_usd
    FROM (SELECT day,
    MAX(CASE WHEN series = 'intents_volume_usd' THEN value END) AS volume_usd,
    MAX(CASE WHEN series = 'intents_fees_usd' THEN value END) AS fees_usd,
    MAX(CASE WHEN series = 'intents_revenue_usd' THEN value END) AS revenue_usd,
    MAX(CASE WHEN series = 'intents_buybacks_usd' THEN value END) AS buybacks_usd,
    MAX(CASE WHEN series = 'near_price_usd' THEN value END) AS price_usd
  FROM daily_series
  WHERE series IN ('intents_volume_usd', 'intents_fees_usd', 'intents_revenue_usd', 'intents_buybacks_usd', 'near_price_usd')
  GROUP BY day) p))
SELECT t.day AS through_day, COUNT(*) AS days,
  SUM(volume_usd) AS volume_usd, SUM(fees_usd) AS fees_usd, SUM(revenue_usd) AS revenue_usd, SUM(buybacks_usd) AS buybacks_usd,
  SUM(bought_near) AS bought_near,
  SUM(fees_usd) / SUM(volume_usd) AS fees_of_volume,
  SUM(revenue_usd) / SUM(fees_usd) AS revenue_of_fees,
  SUM(buybacks_usd) / SUM(revenue_usd) AS buybacks_of_revenue,
  SUM(buybacks_usd) / SUM(fees_usd) AS capture_rate,
  SUM(bought_near) * 365.0 / 30 / (SELECT market_cap_usd / price_usd FROM coins_latest WHERE coin_id = 'near') AS bought_yearly_share_of_circulating
FROM flows, fees_through t
WHERE flows.day > date(t.day, '-30 days') AND flows.day <= t.day

Filled by: Dune near/near-intents query 5179085 "NEAR Intents - All-time Volume" (daily volume, public and confidential, latest run); Dune near/near-intents query 6162763 "Total generated fees All-time" (daily gross fees, latest run); DefiLlama GET /summary/dexs/near-intents (daily volume); DefiLlama GET /summary/fees/near-intents?dataType=dailyFees; DefiLlama GET /summary/fees/near-intents?dataType=dailyRevenue; DefiLlama GET /summary/fees/near-intents?dataType=dailyHoldersRevenue; CoinGecko GET /coins/near/market_chart?days=365 (daily price); CoinGecko GET /coins/markets (price, market cap, FDV, rank)
Calculated further in: src/ingest/jobs/merge-intents.ts · mergeIntentsFlows; src/lib/metrics.ts · feeChain, toNear
Run it yourself: npm run query -- fee-chain-30d
Shown on: Revenue

fee-rate-monthly

NEAR Intents fees per $1M swapped, by month

NEAR Intents gross fees against its volume over the 30 and 90 days to the fee windows' last day and each calendar month through that day, as dollars of fees per $1 million swapped.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), fees_through AS (
  SELECT CASE WHEN COUNT(day) = 3 THEN MIN(day) END AS day FROM (
    SELECT day FROM through
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_fees_usd'
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_revenue_usd')), flows AS (
  SELECT day, volume_usd, fees_usd, revenue_usd, buybacks_usd, price_usd,
    buybacks_usd / price_usd AS bought_near, revenue_usd / price_usd AS revenue_near
  FROM (SELECT p.day, p.volume_usd, p.fees_usd, p.revenue_usd, p.buybacks_usd, COALESCE(p.price_usd, (SELECT h.value FROM daily_series h WHERE h.series = 'near_price_history_usd' AND h.day = p.day
      AND h.day < (SELECT MIN(day) FROM daily_series WHERE series = 'near_price_usd'))) AS price_usd
    FROM (SELECT day,
    MAX(CASE WHEN series = 'intents_volume_usd' THEN value END) AS volume_usd,
    MAX(CASE WHEN series = 'intents_fees_usd' THEN value END) AS fees_usd,
    MAX(CASE WHEN series = 'intents_revenue_usd' THEN value END) AS revenue_usd,
    MAX(CASE WHEN series = 'intents_buybacks_usd' THEN value END) AS buybacks_usd,
    MAX(CASE WHEN series = 'near_price_usd' THEN value END) AS price_usd
  FROM daily_series
  WHERE series IN ('intents_volume_usd', 'intents_fees_usd', 'intents_revenue_usd', 'intents_buybacks_usd', 'near_price_usd')
  GROUP BY day) p)), windows(days) AS (VALUES (30), (90))
SELECT 'last ' || w.days || ' days' AS month, COUNT(*) AS days, SUM(volume_usd) AS volume_usd, SUM(fees_usd) AS fees_usd,
  SUM(fees_usd) / SUM(volume_usd) * 1000000 AS fees_per_1m_usd
FROM windows w, flows, fees_through t
WHERE flows.day > date(t.day, '-' || w.days || ' days') AND flows.day <= t.day
GROUP BY w.days
UNION ALL
SELECT substr(flows.day, 1, 7) AS month, COUNT(*) AS days, SUM(volume_usd) AS volume_usd, SUM(fees_usd) AS fees_usd,
  SUM(fees_usd) / SUM(volume_usd) * 1000000 AS fees_per_1m_usd
FROM flows, fees_through t
WHERE fees_usd IS NOT NULL AND volume_usd > 0 AND flows.day <= t.day
GROUP BY substr(flows.day, 1, 7)
ORDER BY month DESC

Filled by: Dune near/near-intents query 5179085 "NEAR Intents - All-time Volume" (daily volume, public and confidential, latest run); Dune near/near-intents query 6162763 "Total generated fees All-time" (daily gross fees, latest run); DefiLlama GET /summary/dexs/near-intents (daily volume); DefiLlama GET /summary/fees/near-intents?dataType=dailyFees
Calculated further in: src/lib/metrics.ts · feeChain, monthlyTable
Run it yourself: npm run query -- fee-rate-monthly
Shown on: Revenue

fee-channels

NEAR Intents fees by channel

Gross fees each channel (the referral a swap carries: a front end, wallet or app) generated from NEAR Intents' launch through as_of, with its share of the listed channels' fees. Dune lists the 100 largest channels above $10 and leaves out swaps without a referral.

Run CSV

SELECT channel, fees_usd, fees_usd / (SELECT SUM(fees_usd) FROM intents_fee_channels) AS share, as_of
FROM intents_fee_channels
ORDER BY fees_usd DESC

Filled by: Dune near/near-intents query 6162721 "Total generated fees by channel" (fees since launch for the 100 largest channels above $10, latest run)
Run it yourself: npm run query -- fee-channels
Shown on: Revenue

capture-rate-monthly

Share of fees that buys NEAR, by month

Buyback dollars against NEAR Intents gross fees over the 90 days to the fee windows' last day and by calendar month through that day. Fees count from 2026-02-23, the first day of buying, so the month buying began is not diluted by the days before it.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), fees_through AS (
  SELECT CASE WHEN COUNT(day) = 3 THEN MIN(day) END AS day FROM (
    SELECT day FROM through
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_fees_usd'
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_revenue_usd')), flows AS (
  SELECT day, volume_usd, fees_usd, revenue_usd, buybacks_usd, price_usd,
    buybacks_usd / price_usd AS bought_near, revenue_usd / price_usd AS revenue_near
  FROM (SELECT p.day, p.volume_usd, p.fees_usd, p.revenue_usd, p.buybacks_usd, COALESCE(p.price_usd, (SELECT h.value FROM daily_series h WHERE h.series = 'near_price_history_usd' AND h.day = p.day
      AND h.day < (SELECT MIN(day) FROM daily_series WHERE series = 'near_price_usd'))) AS price_usd
    FROM (SELECT day,
    MAX(CASE WHEN series = 'intents_volume_usd' THEN value END) AS volume_usd,
    MAX(CASE WHEN series = 'intents_fees_usd' THEN value END) AS fees_usd,
    MAX(CASE WHEN series = 'intents_revenue_usd' THEN value END) AS revenue_usd,
    MAX(CASE WHEN series = 'intents_buybacks_usd' THEN value END) AS buybacks_usd,
    MAX(CASE WHEN series = 'near_price_usd' THEN value END) AS price_usd
  FROM daily_series
  WHERE series IN ('intents_volume_usd', 'intents_fees_usd', 'intents_revenue_usd', 'intents_buybacks_usd', 'near_price_usd')
  GROUP BY day) p)), windows(days) AS (VALUES (90))
SELECT 'last ' || w.days || ' days' AS month, COUNT(*) AS days, SUM(buybacks_usd > 0) AS buying_days, SUM(fees_usd) AS fees_usd,
  SUM(CASE WHEN flows.day >= '2026-02-23' THEN fees_usd END) AS fees_since_buybacks_usd, SUM(buybacks_usd) AS buybacks_usd,
  SUM(buybacks_usd) / SUM(CASE WHEN flows.day >= '2026-02-23' THEN fees_usd END) AS capture_rate
FROM windows w, flows, fees_through t
WHERE flows.day > date(t.day, '-' || w.days || ' days') AND flows.day <= t.day
GROUP BY w.days
UNION ALL
SELECT substr(flows.day, 1, 7) AS month, COUNT(*) AS days, SUM(buybacks_usd > 0) AS buying_days, SUM(fees_usd) AS fees_usd,
  SUM(CASE WHEN flows.day >= '2026-02-23' THEN fees_usd END) AS fees_since_buybacks_usd, SUM(buybacks_usd) AS buybacks_usd,
  SUM(buybacks_usd) / SUM(CASE WHEN flows.day >= '2026-02-23' THEN fees_usd END) AS capture_rate
FROM flows, fees_through t
WHERE fees_usd IS NOT NULL AND flows.day <= t.day
GROUP BY month
ORDER BY month DESC

Filled by: Dune near/near-intents query 6162763 "Total generated fees All-time" (daily gross fees, latest run); DefiLlama GET /summary/fees/near-intents?dataType=dailyFees; DefiLlama GET /summary/fees/near-intents?dataType=dailyHoldersRevenue
Run it yourself: npm run query -- capture-rate-monthly
Shown on: Revenue

bought-by-month

NEAR bought by month

NEAR bought each calendar month through the data-through day, with each day's buybacks converted at that day's NEAR price.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), flows AS (
  SELECT day, volume_usd, fees_usd, revenue_usd, buybacks_usd, price_usd,
    buybacks_usd / price_usd AS bought_near, revenue_usd / price_usd AS revenue_near
  FROM (SELECT p.day, p.volume_usd, p.fees_usd, p.revenue_usd, p.buybacks_usd, COALESCE(p.price_usd, (SELECT h.value FROM daily_series h WHERE h.series = 'near_price_history_usd' AND h.day = p.day
      AND h.day < (SELECT MIN(day) FROM daily_series WHERE series = 'near_price_usd'))) AS price_usd
    FROM (SELECT day,
    MAX(CASE WHEN series = 'intents_volume_usd' THEN value END) AS volume_usd,
    MAX(CASE WHEN series = 'intents_fees_usd' THEN value END) AS fees_usd,
    MAX(CASE WHEN series = 'intents_revenue_usd' THEN value END) AS revenue_usd,
    MAX(CASE WHEN series = 'intents_buybacks_usd' THEN value END) AS buybacks_usd,
    MAX(CASE WHEN series = 'near_price_usd' THEN value END) AS price_usd
  FROM daily_series
  WHERE series IN ('intents_volume_usd', 'intents_fees_usd', 'intents_revenue_usd', 'intents_buybacks_usd', 'near_price_usd')
  GROUP BY day) p))
SELECT substr(flows.day, 1, 7) AS month, COUNT(*) AS days, SUM(buybacks_usd) AS buybacks_usd, SUM(bought_near) AS bought_near
FROM flows, through t
WHERE buybacks_usd > 0 AND flows.day <= t.day
GROUP BY month
ORDER BY month DESC

Filled by: DefiLlama GET /summary/fees/near-intents?dataType=dailyHoldersRevenue; CoinGecko GET /coins/near/market_chart?days=365 (daily price)
Calculated further in: src/lib/metrics.ts · toNear, monthlySums
Run it yourself: npm run query -- bought-by-month
Shown on: Revenue

revenue-units

NEAR Intents revenue in dollars and in NEAR

Monthly NEAR Intents revenue through the fee windows' last day, in USD and in NEAR (each day at its own price), in total and a day. The chart uses revenue a day in months with revenue on every day and indexes both to 100 in the first.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), fees_through AS (
  SELECT CASE WHEN COUNT(day) = 3 THEN MIN(day) END AS day FROM (
    SELECT day FROM through
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_fees_usd'
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_revenue_usd')), flows AS (
  SELECT day, volume_usd, fees_usd, revenue_usd, buybacks_usd, price_usd,
    buybacks_usd / price_usd AS bought_near, revenue_usd / price_usd AS revenue_near
  FROM (SELECT p.day, p.volume_usd, p.fees_usd, p.revenue_usd, p.buybacks_usd, COALESCE(p.price_usd, (SELECT h.value FROM daily_series h WHERE h.series = 'near_price_history_usd' AND h.day = p.day
      AND h.day < (SELECT MIN(day) FROM daily_series WHERE series = 'near_price_usd'))) AS price_usd
    FROM (SELECT day,
    MAX(CASE WHEN series = 'intents_volume_usd' THEN value END) AS volume_usd,
    MAX(CASE WHEN series = 'intents_fees_usd' THEN value END) AS fees_usd,
    MAX(CASE WHEN series = 'intents_revenue_usd' THEN value END) AS revenue_usd,
    MAX(CASE WHEN series = 'intents_buybacks_usd' THEN value END) AS buybacks_usd,
    MAX(CASE WHEN series = 'near_price_usd' THEN value END) AS price_usd
  FROM daily_series
  WHERE series IN ('intents_volume_usd', 'intents_fees_usd', 'intents_revenue_usd', 'intents_buybacks_usd', 'near_price_usd')
  GROUP BY day) p))
SELECT substr(flows.day, 1, 7) AS month, COUNT(*) AS days, SUM(revenue_usd > 0) AS revenue_days, SUM(revenue_usd) AS revenue_usd, SUM(revenue_near) AS revenue_near,
  SUM(revenue_usd) / SUM(revenue_usd > 0) AS revenue_usd_per_day, SUM(revenue_near) / SUM(revenue_usd > 0) AS revenue_near_per_day
FROM flows, fees_through t
WHERE revenue_usd IS NOT NULL AND price_usd IS NOT NULL AND flows.day <= t.day
GROUP BY month
ORDER BY month DESC

Filled by: DefiLlama GET /summary/fees/near-intents?dataType=dailyRevenue; CoinGecko GET /coins/near/market_chart?days=365 (daily price)
Calculated further in: src/lib/metrics.ts · toNear, indexTo100
Run it yourself: npm run query -- revenue-units
Shown on: Revenue

fee-wallets

NEAR in the three fee wallets

NEAR held by each of the three fee wallets at the end of each finished UTC day; today's row is the latest NEAR RPC reading.

Run CSV

SELECT day, buyback_near, frontend_near, one_click_near, buyback_near + frontend_near + one_click_near AS total_near
FROM (SELECT day,
    MAX(CASE WHEN series = 'buyback_wallet_near' THEN value END) AS buyback_near,
    MAX(CASE WHEN series = 'frontend_fee_wallet_near' THEN value END) AS frontend_near,
    MAX(CASE WHEN series = 'one_click_fee_wallet_near' THEN value END) AS one_click_near
  FROM daily_series
  WHERE series IN ('buyback_wallet_near', 'frontend_fee_wallet_near', 'one_click_fee_wallet_near')
  GROUP BY day)
ORDER BY day DESC

Filled by: NEAR RPC view_account for buybacks.multisignature.near, fefundsadmin.sputnik-dao.near, 1csfundsadmin.sputnik-dao.near (today); NearBlocks GET /v3/accounts/{wallet}/stats/balance (finished days)
Run it yourself: npm run query -- fee-wallets
Shown on: Revenue

burn-by-month

NEAR burned by month

NEAR burned over the 30 days to the data-through day and each month, measured from block headers, with the burned share of gas fees on the days both are stored.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), supply_flows AS (
  SELECT day, minted_near, burnt_near, buybacks_usd / price_usd AS bought_near, chain_fees_usd / price_usd AS fees_near
  FROM (SELECT p.day, p.minted_near, p.burnt_near, p.buybacks_usd, p.chain_fees_usd, COALESCE(p.price_usd, (SELECT h.value FROM daily_series h WHERE h.series = 'near_price_history_usd' AND h.day = p.day
      AND h.day < (SELECT MIN(day) FROM daily_series WHERE series = 'near_price_usd'))) AS price_usd
    FROM (SELECT day,
    MAX(CASE WHEN series = 'minted_near' THEN value END) AS minted_near,
    MAX(CASE WHEN series = 'burnt_near' THEN value END) AS burnt_near,
    MAX(CASE WHEN series = 'intents_buybacks_usd' THEN value END) AS buybacks_usd,
    MAX(CASE WHEN series = 'near_chain_fees_usd' THEN value END) AS chain_fees_usd,
    MAX(CASE WHEN series = 'near_price_usd' THEN value END) AS price_usd
  FROM daily_series
  WHERE series IN ('minted_near', 'burnt_near', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
  GROUP BY day) p)), windows(days) AS (VALUES (30))
SELECT 'last ' || w.days || ' days' AS month, COUNT(burnt_near) AS days, SUM(burnt_near) AS burnt_near, SUM(fees_near) AS gas_fees_near,
  SUM(CASE WHEN fees_near IS NOT NULL THEN burnt_near END) / SUM(fees_near) AS burn_share
FROM windows w, supply_flows, through t
WHERE burnt_near IS NOT NULL AND supply_flows.day > date(t.day, '-' || w.days || ' days') AND supply_flows.day <= t.day
GROUP BY w.days
UNION ALL
SELECT substr(supply_flows.day, 1, 7) AS month, COUNT(burnt_near) AS days, SUM(burnt_near) AS burnt_near, SUM(fees_near) AS gas_fees_near,
  SUM(CASE WHEN fees_near IS NOT NULL THEN burnt_near END) / SUM(fees_near) AS burn_share
FROM supply_flows, through t
WHERE burnt_near IS NOT NULL AND supply_flows.day <= t.day
GROUP BY month
ORDER BY month DESC

Filled by: NEAR archival RPC block (by height or hash) at each epoch boundary; DefiLlama GET /summary/fees/near; CoinGecko GET /coins/near/market_chart?days=365 (daily price)
Calculated further in: src/ingest/sources/near.ts · epochSupply; src/ingest/days.ts · spreadOverDays
Run it yourself: npm run query -- burn-by-month
Shown on: Revenue

Supply

absorption

New supply absorbed by burn and buybacks

NEAR burned and bought against NEAR minted over the 30 and 90 days, the days since buybacks began on 2026-02-23, and the 365 days to the data-through day. A window counts only when NEAR minted, burned and bought cover every one of its days.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), supply_flows AS (
  SELECT day, minted_near, burnt_near, buybacks_usd / price_usd AS bought_near, chain_fees_usd / price_usd AS fees_near
  FROM (SELECT p.day, p.minted_near, p.burnt_near, p.buybacks_usd, p.chain_fees_usd, COALESCE(p.price_usd, (SELECT h.value FROM daily_series h WHERE h.series = 'near_price_history_usd' AND h.day = p.day
      AND h.day < (SELECT MIN(day) FROM daily_series WHERE series = 'near_price_usd'))) AS price_usd
    FROM (SELECT day,
    MAX(CASE WHEN series = 'minted_near' THEN value END) AS minted_near,
    MAX(CASE WHEN series = 'burnt_near' THEN value END) AS burnt_near,
    MAX(CASE WHEN series = 'intents_buybacks_usd' THEN value END) AS buybacks_usd,
    MAX(CASE WHEN series = 'near_chain_fees_usd' THEN value END) AS chain_fees_usd,
    MAX(CASE WHEN series = 'near_price_usd' THEN value END) AS price_usd
  FROM daily_series
  WHERE series IN ('minted_near', 'burnt_near', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
  GROUP BY day) p)),
windows AS (
  SELECT '30 days' AS name, 30 AS days UNION ALL SELECT '90 days', 90
  UNION ALL SELECT 'since buybacks began', CAST(julianday(day) - julianday('2026-02-23') + 1 AS INTEGER) FROM through
  UNION ALL SELECT '365 days', 365)
SELECT w.name AS window_name, w.days, t.day AS through_day, COUNT(minted_near) AS minted_days,
  SUM(minted_near) AS minted_near, SUM(burnt_near) AS burnt_near, SUM(bought_near) AS bought_near,
  SUM(burnt_near) / SUM(minted_near) AS burnt_share,
  SUM(bought_near) / SUM(minted_near) AS bought_share,
  (SUM(burnt_near) + SUM(bought_near)) / SUM(minted_near) AS absorbed_share
FROM windows w, through t, supply_flows f
WHERE f.day > date(t.day, '-' || w.days || ' days') AND f.day <= t.day
GROUP BY w.name, w.days
HAVING COUNT(minted_near) = w.days AND COUNT(burnt_near) = w.days AND COUNT(bought_near) = w.days
ORDER BY w.days, w.name

Filled by: NEAR archival RPC block (by height or hash) at each epoch boundary; DefiLlama GET /summary/fees/near-intents?dataType=dailyHoldersRevenue; CoinGecko GET /coins/near/market_chart?days=365 (daily price)
Calculated further in: src/lib/metrics.ts · absorption, coversWindow
Run it yourself: npm run query -- absorption
Shown on: Supply

absorption-monthly

New supply absorbed by month

Each calendar month's NEAR burned and bought as shares of the NEAR minted that month.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), supply_flows AS (
  SELECT day, minted_near, burnt_near, buybacks_usd / price_usd AS bought_near, chain_fees_usd / price_usd AS fees_near
  FROM (SELECT p.day, p.minted_near, p.burnt_near, p.buybacks_usd, p.chain_fees_usd, COALESCE(p.price_usd, (SELECT h.value FROM daily_series h WHERE h.series = 'near_price_history_usd' AND h.day = p.day
      AND h.day < (SELECT MIN(day) FROM daily_series WHERE series = 'near_price_usd'))) AS price_usd
    FROM (SELECT day,
    MAX(CASE WHEN series = 'minted_near' THEN value END) AS minted_near,
    MAX(CASE WHEN series = 'burnt_near' THEN value END) AS burnt_near,
    MAX(CASE WHEN series = 'intents_buybacks_usd' THEN value END) AS buybacks_usd,
    MAX(CASE WHEN series = 'near_chain_fees_usd' THEN value END) AS chain_fees_usd,
    MAX(CASE WHEN series = 'near_price_usd' THEN value END) AS price_usd
  FROM daily_series
  WHERE series IN ('minted_near', 'burnt_near', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
  GROUP BY day) p))
SELECT substr(supply_flows.day, 1, 7) AS month, COUNT(*) AS days, SUM(minted_near) AS minted_near, SUM(burnt_near) AS burnt_near,
  SUM(bought_near) AS bought_near, (SUM(burnt_near) + COALESCE(SUM(bought_near), 0)) / SUM(minted_near) AS absorbed_share
FROM supply_flows, through t
WHERE minted_near IS NOT NULL AND burnt_near IS NOT NULL AND supply_flows.day <= t.day
GROUP BY month
ORDER BY month DESC

Filled by: NEAR archival RPC block (by height or hash) at each epoch boundary; DefiLlama GET /summary/fees/near-intents?dataType=dailyHoldersRevenue; CoinGecko GET /coins/near/market_chart?days=365 (daily price)
Run it yourself: npm run query -- absorption-monthly
Shown on: Supply

epoch-supply

NEAR minted and burned per epoch

Every stored epoch with its total supply at the first and last block, and the NEAR minted and burned, measured from block headers.

Run CSV

SELECT epoch_id, start_height, start_time, end_height, end_time, supply_start_near, supply_end_near, minted_near, burnt_near
FROM epoch_supply
ORDER BY start_height DESC

Filled by: NEAR archival RPC block (by height or hash) at each epoch boundary
Calculated further in: src/ingest/sources/near.ts · epochSupply
Run it yourself: npm run query -- epoch-supply
Shown on: Supply

total-supply

Total NEAR supply

Total NEAR supply by day.

Run CSV

SELECT day, value AS total_supply_near
FROM daily_series
WHERE series = 'near_total_supply'
ORDER BY day DESC

Filled by: NearBlocks GET /v3/txn-stats, /v3/block-stats and /v3/address-stats (daily, last 365 days; older days from GET /v1/charts); NEAR RPC block (finality final)
Run it yourself: npm run query -- total-supply
Shown on: Supply

protocol-treasury

NEAR in the protocol treasury

treasury.near's NEAR at the end of each day, its gain over the 30 days to that day, and 10% of the NEAR minted in those days (what the protocol pays it).

Run CSV

SELECT t.day, t.value AS treasury_near,
  t.value - (SELECT p.value FROM daily_series p WHERE p.series = 'treasury_near' AND p.day = date(t.day, '-30 days')) AS gain_30d_near,
  (SELECT SUM(m.value) FROM daily_series m
   WHERE m.series = 'minted_near' AND m.day > date(t.day, '-30 days') AND m.day <= t.day) * 0.1 AS paid_30d_near
FROM daily_series t
WHERE t.series = 'treasury_near'
  AND t.day <= (SELECT MAX(day) FROM daily_series WHERE series = 'minted_near')
ORDER BY t.day DESC

Filled by: NEAR RPC view_account for treasury.near (today); NearBlocks GET /v3/accounts/treasury.near/stats/balance (finished days); NEAR archival RPC block (by height or hash) at each epoch boundary
Calculated further in: src/data/thesis-metrics/supply.ts · treasuryWindow, treasuryMetrics (gain and share over the 30 days both cover)
Run it yourself: npm run query -- protocol-treasury
Shown on: Supply

hsp029-vote

HSP-029 vote

The House of Stake vote on HSP-029 as last read from the voting contract.

Run CSV

SELECT proposal_id, title, status, venear_for, venear_against, venear_abstain, venear_snapshot, voters,
  quorum_threshold_bps, approval_threshold_bps, voting_ends_at, timelock_ends_at, fetched_at
FROM governance_proposals

Filled by: NEAR RPC call_function get_proposal on vote.dao
Run it yourself: npm run query -- hsp029-vote
Shown on: Supply

Valuation

projection-inputs

Starting values of the projections

Every projection and the model start from these values, taken over the 30 days to the data-through day. NEAR bought: the NEAR the 30 days' buyback dollars buy at today's price, as a monthly amount (the projections hold today's price), with the NEAR actually bought at each day's price beside it. Burn: gas fees in NEAR as a monthly amount, NEAR burned, the measured burned share of gas fees, and the share the projections burn (all of it once the protocol pays no gas to contracts). Volume: Intents volume over the 30 days and as a monthly amount, the share of volume that buys NEAR, which sets the volume a scenario needs, its multiple of the 30-day run rate and break-even, the fee rate (gross fees ÷ volume over the 30 days to the fee windows' last day, as the newest day of fees is still filling) and the share of fees that buys NEAR (share of volume that buys NEAR ÷ fee rate). Growth: NEAR bought over the 90 days to the data-through day against the 90 before, and as a monthly rate for the 90-day pace scenario; none until both 90-day windows fall after buying began. Market and protocol: today's price, market cap, total supply and max issuance rate, the NEAR minted behind break-even, and the end of HSP-029's timelock, which its ramp starts from.

Run CSV

WITH through AS (
  SELECT CASE WHEN COUNT(*) = 4 THEN MIN(last_day) END AS day FROM (
    SELECT MAX(day) AS last_day FROM daily_series
    WHERE series IN ('intents_volume_usd', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
    GROUP BY series)), fees_through AS (
  SELECT CASE WHEN COUNT(day) = 3 THEN MIN(day) END AS day FROM (
    SELECT day FROM through
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_fees_usd'
    UNION ALL SELECT MAX(day) FROM daily_series WHERE series = 'intents_revenue_usd')), flows AS (
  SELECT day, volume_usd, fees_usd, revenue_usd, buybacks_usd, price_usd,
    buybacks_usd / price_usd AS bought_near, revenue_usd / price_usd AS revenue_near
  FROM (SELECT p.day, p.volume_usd, p.fees_usd, p.revenue_usd, p.buybacks_usd, COALESCE(p.price_usd, (SELECT h.value FROM daily_series h WHERE h.series = 'near_price_history_usd' AND h.day = p.day
      AND h.day < (SELECT MIN(day) FROM daily_series WHERE series = 'near_price_usd'))) AS price_usd
    FROM (SELECT day,
    MAX(CASE WHEN series = 'intents_volume_usd' THEN value END) AS volume_usd,
    MAX(CASE WHEN series = 'intents_fees_usd' THEN value END) AS fees_usd,
    MAX(CASE WHEN series = 'intents_revenue_usd' THEN value END) AS revenue_usd,
    MAX(CASE WHEN series = 'intents_buybacks_usd' THEN value END) AS buybacks_usd,
    MAX(CASE WHEN series = 'near_price_usd' THEN value END) AS price_usd
  FROM daily_series
  WHERE series IN ('intents_volume_usd', 'intents_fees_usd', 'intents_revenue_usd', 'intents_buybacks_usd', 'near_price_usd')
  GROUP BY day) p)), supply_flows AS (
  SELECT day, minted_near, burnt_near, buybacks_usd / price_usd AS bought_near, chain_fees_usd / price_usd AS fees_near
  FROM (SELECT p.day, p.minted_near, p.burnt_near, p.buybacks_usd, p.chain_fees_usd, COALESCE(p.price_usd, (SELECT h.value FROM daily_series h WHERE h.series = 'near_price_history_usd' AND h.day = p.day
      AND h.day < (SELECT MIN(day) FROM daily_series WHERE series = 'near_price_usd'))) AS price_usd
    FROM (SELECT day,
    MAX(CASE WHEN series = 'minted_near' THEN value END) AS minted_near,
    MAX(CASE WHEN series = 'burnt_near' THEN value END) AS burnt_near,
    MAX(CASE WHEN series = 'intents_buybacks_usd' THEN value END) AS buybacks_usd,
    MAX(CASE WHEN series = 'near_chain_fees_usd' THEN value END) AS chain_fees_usd,
    MAX(CASE WHEN series = 'near_price_usd' THEN value END) AS price_usd
  FROM daily_series
  WHERE series IN ('minted_near', 'burnt_near', 'intents_buybacks_usd', 'near_chain_fees_usd', 'near_price_usd')
  GROUP BY day) p)),
fees30 AS (
  SELECT SUM(f.fees_usd) / SUM(f.volume_usd) AS fee_rate
  FROM flows f, fees_through t
  WHERE f.day > date(t.day, '-30 days') AND f.day <= t.day
  HAVING COUNT(f.fees_usd) = 30 AND COUNT(f.volume_usd) = 30),
last30 AS (
  SELECT SUM(f.minted_near) AS minted_near, SUM(f.bought_near) AS bought_near, SUM(f.fees_near) AS fees_near, SUM(f.burnt_near) AS burnt_near
  FROM supply_flows f, through t
  WHERE f.day > date(t.day, '-30 days') AND f.day <= t.day),
take30 AS (
  SELECT SUM(f.buybacks_usd) AS buybacks_usd, SUM(f.volume_usd) AS volume_usd, SUM(f.buybacks_usd) / SUM(f.volume_usd) AS take_rate
  FROM flows f, through t
  WHERE f.day > date(t.day, '-30 days') AND f.day <= t.day),
bought90 AS (
  SELECT CASE WHEN date(t.day, '-179 days') >= '2026-02-23' AND COUNT(f.bought_near) = 180 THEN
      SUM(CASE WHEN f.day > date(t.day, '-90 days') THEN f.bought_near END) / SUM(CASE WHEN f.day <= date(t.day, '-90 days') THEN f.bought_near END) - 1
    END AS change_90d
  FROM flows f, through t
  WHERE f.day > date(t.day, '-180 days') AND f.day <= t.day)
SELECT t.day AS through_day, c.price_usd, c.market_cap_usd, n.total_supply_near, n.max_inflation_rate,
  w.buybacks_usd / c.price_usd * 365.0 / 30 / 12 AS bought_near_per_month,
  l.fees_near * 365.0 / 30 / 12 AS fees_near_per_month,
  l.burnt_near / l.fees_near AS measured_burn_share,
  CASE WHEN n.burnt_gas_share_to_contracts = 0 THEN 1.0 ELSE l.burnt_near / l.fees_near END AS burn_share_of_fees,
  w.take_rate AS take_rate_30d,
  w.volume_usd AS volume_30d_usd,
  w.volume_usd * 365.0 / 30 / 12 AS volume_usd_per_month,
  (SELECT fee_rate FROM fees30) AS fee_rate_30d,
  w.take_rate / (SELECT fee_rate FROM fees30) AS capture_rate_30d,
  b.change_90d AS bought_change_90d,
  pow(1 + b.change_90d, 365.0 / 12 / 90) - 1 AS bought_monthly_growth,
  l.minted_near AS minted_near_30d,
  l.burnt_near AS burnt_near_30d,
  l.bought_near AS bought_near_30d,
  (SELECT timelock_ends_at FROM governance_proposals WHERE contract = 'vote.dao' AND proposal_id = 29) AS hsp029_timelock_ends_at
FROM through t, last30 l, take30 w, bought90 b, coins_latest c, network_latest n
WHERE c.coin_id = 'near'

Filled by: DefiLlama GET /summary/fees/near-intents?dataType=dailyHoldersRevenue; Dune near/near-intents query 5179085 "NEAR Intents - All-time Volume" (daily volume, public and confidential, latest run); DefiLlama GET /summary/dexs/near-intents (daily volume); Dune near/near-intents query 6162763 "Total generated fees All-time" (daily gross fees, latest run); DefiLlama GET /summary/fees/near-intents?dataType=dailyFees; DefiLlama GET /summary/fees/near; NEAR archival RPC block (by height or hash) at each epoch boundary; CoinGecko GET /coins/near/market_chart?days=365 (daily price); CoinGecko GET /coins/markets (price, market cap, FDV, rank); NEAR RPC block (finality final); NEAR RPC EXPERIMENTAL_protocol_config; NEAR RPC call_function get_proposal on vote.dao
Calculated further in: src/lib/projection.ts · coverageScenarios, coveringGrowth (month-by-month projection from these values)
Run it yourself: npm run query -- projection-inputs
Shown on: Valuation

revenue-multiple

NEAR market cap ÷ network revenue

NEAR's market cap each day against its network revenue (NEAR Intents revenue plus gas fees) of the 30 days to that day, annualized. It starts once the whole 30-day window falls in or after the first month with NEAR Intents revenue on every day, because earlier revenue arrived in occasional lumps; days without all 30 days of revenue are left out.

Run CSV

WITH first_full AS (
  SELECT MIN(month) AS month FROM (
    SELECT substr(day, 1, 7) AS month, COUNT(*) AS days FROM daily_series
    WHERE series = 'intents_revenue_usd' AND value > 0
    GROUP BY month
    HAVING days = CAST(strftime('%d', date(month || '-01', '+1 month', '-1 day')) AS INTEGER))),
revenue AS (
  SELECT day, SUM(value) AS revenue_usd, COUNT(*) AS parts FROM daily_series
  WHERE series IN ('intents_revenue_usd', 'near_chain_fees_usd')
  GROUP BY day HAVING parts = 2),
cap AS (
  SELECT s.day, s.circulating_supply * p.value AS market_cap_usd
  FROM coin_supply_daily s JOIN daily_series p ON p.series = 'near_price_usd' AND p.day = s.day
  WHERE s.coin_id = 'near'),
rev30 AS (
  SELECT day, SUM(revenue_usd) OVER w AS revenue_30d_usd, COUNT(*) OVER w AS revenue_days
  FROM revenue
  WINDOW w AS (ORDER BY julianday(day) RANGE BETWEEN 29 PRECEDING AND CURRENT ROW)),
windows AS (
  SELECT c.day, c.market_cap_usd, r.revenue_30d_usd, r.revenue_days
  FROM cap c JOIN rev30 r ON r.day = c.day)
SELECT day, market_cap_usd, revenue_30d_usd, market_cap_usd / (revenue_30d_usd * 365.0 / 30) AS multiple
FROM windows, first_full f
WHERE revenue_days = 30 AND windows.day >= date(f.month || '-01', '+29 days')
ORDER BY day DESC

Filled by: DefiLlama GET /summary/fees/near-intents?dataType=dailyRevenue; DefiLlama GET /summary/fees/near; CoinGecko GET /coins/{id}/market_chart?days=365 (market cap ÷ price); CoinGecko GET /coins/near/market_chart?days=365 (daily price)
Calculated further in: src/lib/metrics.ts · revenueMultiple
Run it yourself: npm run query -- revenue-multiple
Shown on: Valuation

Network

validator-stake

Stake by validator

Validators of the latest stored epoch by stake, with their running share; the rank of the first row past a third of all stake is the Nakamoto coefficient (validators = staking pools).

Run CSV

WITH latest AS (SELECT MAX(epoch_height) AS epoch FROM validator_epochs),
v AS (SELECT account_id, stake_near, produces_blocks FROM validator_epochs, latest WHERE epoch_height = latest.epoch),
ranked AS (
  SELECT account_id, stake_near, produces_blocks,
    ROW_NUMBER() OVER (ORDER BY stake_near DESC) AS rank,
    stake_near / SUM(stake_near) OVER () AS share,
    SUM(stake_near) OVER (ORDER BY stake_near DESC ROWS UNBOUNDED PRECEDING) / SUM(stake_near) OVER () AS running_share
  FROM v)
SELECT rank, account_id, stake_near, produces_blocks, share, running_share,
  running_share > 1.0 / 3 AND running_share - share <= 1.0 / 3 AS reaches_a_third
FROM ranked
ORDER BY rank

Filled by: NEAR RPC validators
Calculated further in: src/lib/metrics.ts · nakamotoCoefficient, seatPrices
Run it yourself: npm run query -- validator-stake
Shown on: Network

developers

Monthly active developers

Monthly active developers for NEAR, Ethereum, Solana and Bitcoin on the first of each month.

Run CSV

SELECT day, near, near_full_time, ethereum, solana, bitcoin
FROM (SELECT day,
    MAX(CASE WHEN series = 'devs_all_near' THEN value END) AS near,
    MAX(CASE WHEN series = 'devs_full_time_near' THEN value END) AS near_full_time,
    MAX(CASE WHEN series = 'devs_all_ethereum' THEN value END) AS ethereum,
    MAX(CASE WHEN series = 'devs_all_solana' THEN value END) AS solana,
    MAX(CASE WHEN series = 'devs_all_bitcoin' THEN value END) AS bitcoin
  FROM daily_series
  WHERE series IN ('devs_all_near', 'devs_full_time_near', 'devs_all_ethereum', 'devs_all_solana', 'devs_all_bitcoin')
  GROUP BY day)
WHERE substr(day, 9, 2) = '01'
ORDER BY day DESC

Filled by: Open Dev Data eco_mads.parquet
Run it yourself: npm run query -- developers
Shown on: Network

Technology

protocol-releases

Protocol upgrades

The protocol and nearcore versions mainnet and testnet run, beside every stored nearcore release, newest first.

Run CSV

SELECT r.tag, r.name, r.published_at, r.prerelease,
  (SELECT protocol_version FROM protocol_versions WHERE network = 'mainnet') AS mainnet_protocol,
  (SELECT node_version FROM protocol_versions WHERE network = 'mainnet') AS mainnet_node,
  (SELECT protocol_version FROM protocol_versions WHERE network = 'testnet') AS testnet_protocol,
  (SELECT node_version FROM protocol_versions WHERE network = 'testnet') AS testnet_node
FROM releases r
ORDER BY r.published_at DESC

Filled by: GitHub GET /repos/near/nearcore/releases; NEAR RPC status on mainnet and testnet
Run it yourself: npm run query -- protocol-releases
Shown on: Technology

live-activity

Live on NEAR mainnet

The samples behind the live panel: block height and chunk gas each minute over the 2 hours to the newest sample. Transactions a minute come from the daily transaction counts (chain-activity).

Run CSV

SELECT at, metric, value
FROM live_samples
WHERE at >= strftime('%Y-%m-%dT%H:%M:%fZ', (SELECT MAX(at) FROM live_samples), '-120 minutes')
ORDER BY at DESC, metric

Filled by: NEAR RPC block (finality final); NearBlocks GET /v3/txn-stats, /v3/block-stats and /v3/address-stats (daily, last 365 days; older days from GET /v1/charts)
Calculated further in: src/data/live.ts · getLiveSnapshot (block time between samples, transactions a minute from daily counts)
Run it yourself: npm run query -- live-activity
Shown on: Technology

Peers

peer-supply-growth

Circulating supply growth, 12 months

Circulating supply growth of NEAR and every coin ranked above it: the median supply of the newest 7 days against the median of the 7 days ending 365 days earlier (or the first 7 stored days when history is shorter), as a yearly rate. Medians stop a single wrong reading from moving the result; coins with less than 360 days of history are left out.

Run CSV

WITH bounds AS (
  SELECT coin_id, MIN(day) AS first_day, MAX(day) AS last_day FROM coin_supply_daily GROUP BY coin_id),
ends AS (
  SELECT coin_id, last_day,
    CASE WHEN first_day <= date(last_day, '-365 days', '-6 days') THEN date(last_day, '-365 days') ELSE date(first_day, '+6 days') END AS base_day
  FROM bounds
  WHERE julianday(last_day) - julianday(first_day) >= 360),
windowed AS (
  SELECT e.coin_id, e.last_day, e.base_day, CASE WHEN s.day > date(e.last_day, '-7 days') THEN 'now' ELSE 'base' END AS side, s.circulating_supply AS supply
  FROM ends e JOIN coin_supply_daily s ON s.coin_id = e.coin_id
  WHERE s.day > date(e.last_day, '-7 days') OR (s.day > date(e.base_day, '-7 days') AND s.day <= e.base_day)),
ranked AS (
  SELECT *, ROW_NUMBER() OVER (PARTITION BY coin_id, side ORDER BY supply) AS rn, COUNT(*) OVER (PARTITION BY coin_id, side) AS n
  FROM windowed),
medians AS (
  SELECT coin_id, last_day, base_day, side, AVG(supply) AS supply
  FROM ranked
  WHERE rn IN ((n + 1) / 2, (n + 2) / 2)
  GROUP BY coin_id, side)
SELECT c.rank, c.coin_id, c.symbol, now.last_day AS day, now.base_day, julianday(now.last_day) - julianday(now.base_day) AS span_days,
  now.supply AS supply_now_median, base.supply AS supply_base_median,
  pow(now.supply / base.supply, 365.0 / (julianday(now.last_day) - julianday(now.base_day))) - 1 AS growth_1y
FROM medians now
JOIN medians base ON base.coin_id = now.coin_id AND base.side = 'base'
JOIN coins_latest c ON c.coin_id = now.coin_id
WHERE now.side = 'now' AND c.rank <= (SELECT rank FROM coins_latest WHERE coin_id = 'near')
ORDER BY c.rank

Filled by: CoinGecko GET /coins/{id}/market_chart?days=365 (market cap ÷ price); CoinGecko GET /coins/markets (price, market cap, FDV, rank)
Calculated further in: src/data/market.ts · getSupplyGrowth1y; src/lib/metrics.ts · yearlyGrowthOfMedians
Run it yourself: npm run query -- peer-supply-growth
Shown on: Peers

peer-markets

The coins ranked above NEAR

The latest price, market cap and FDV of NEAR and every coin ranked above it, with FDV ÷ market cap (1 when CoinGecko gives no FDV), the price change over a year and the distance from the all-time high.

Run CSV

SELECT rank, coin_id, symbol, price_usd, market_cap_usd, fdv_usd, COALESCE(fdv_usd, market_cap_usd) / market_cap_usd AS fdv_to_market_cap,
  change_1y / 100 AS change_1y, price_usd / ath_usd - 1 AS from_ath, fetched_at
FROM coins_latest
WHERE rank <= (SELECT rank FROM coins_latest WHERE coin_id = 'near')
ORDER BY rank

Filled by: CoinGecko GET /coins/markets (price, market cap, FDV, rank)
Run it yourself: npm run query -- peer-markets
Shown on: Peers