NEAR has become the exchange everyone asked for but nobody shipped.

  • Private and simple like a CEX, without the formalities. Send in one coin, take out another. Nothing public links the two, and nobody asks for your ID.
  • Yours, and fair, like a DEX. It starts and ends in your own wallet. No account, and no house setting the price: solvers compete for your swap.
What happens
For
Against
Watch

Follow the fee

who payssettled by NEAR Intentswho is paid
Query
GET explorer.near-intents.org/api/v0/transactions      -- every successful partner swap in the window

-- left:  fee dollars by what was swapped   (sum(amountInUsd * appFees[].fee / 10000), grouped as in "Who's paying?")
-- right: the same dollars by appFees[].recipient; the three NEAR revenue wallets are drawn in green
-- band width is proportional to dollars; code: pipeline/swaps.py

The week it went dark

public readable on-chain %#&$@ confidential ·
Query
-- NEAR's own saved query: dune.com/queries/5179085 (dataset dune.near.dataset_near_intents_metrics)
select date_at,
       sum(case when source_type = 'public'       then cast(volume_amount_usd as double) end) as public_volume_usd,
       sum(case when source_type = 'confidential' then cast(volume_amount_usd as double) end) as confidential_volume_usd
from dune.near.dataset_near_intents_metrics
group by date_at

-- cross-check: api.llama.fi/summary/dexs/near-intents?dataType=dailyVolume
-- (equals public before 2026-09-01 and public + confidential from that day on)

The scorecard

. Every number is rebuilt by one command, and each group says where it comes from.

reading the chain…

    Who's paying?

    ;:+/| share of volumefees share of fees
    Query
    GET explorer.near-intents.org/api/v0/transactions
        ?statuses=SUCCESS,REFUNDED,FAILED&numberOfTransactions=1000
        &startTimestampUnix={day start}&endTimestampUnix={cursor}     -- paged back through each day
    
    -- per successful swap:  fee = amountInUsd * sum(appFees[].fee) / 10000
    -- group: both sides in {USDC, USDT, DAI} -> stablecoin pair; else touches BTC -> Bitcoin;
    --        else ZEC -> Zcash; else LTC / DOGE / BCH -> other UTXO coin; else everything else
    -- code: pipeline/swaps.py

    Nobody opens a NEAR app

    name share of partner volumeright: fee in bps · bps named to NEAR
    Query
    -- same swap records as "Who's paying?", grouped by the referral field
    -- fee charged   = sum(amountInUsd * appFees[].fee / 10000) / sum(amountInUsd)
    -- named to NEAR = the part whose appFees[].recipient is one of
    --   buybacks.multisignature.near, fefundsadmin.sputnik-dao.near, 1csfundsadmin.sputnik-dao.near

    The cut is rising

    near what NEAR kept;:+/| the rest of gross fees
    Query
    GET api.llama.fi/summary/fees/near-intents?dataType=dailyFees       -- gross fees, per day
    GET api.llama.fi/summary/fees/near-intents?dataType=dailyRevenue    -- NEAR/wNEAR swept into its revenue wallets, per day
    -- summed by calendar month; share kept = revenue / fees. Full months only.
    -- DefiLlama builds both from NEAR's Dune datasets and the three revenue wallets (see "What the chain says").

    So where's the money?

    account partner's fee accountnear a NEAR revenue wallet
    Query
    -- same swap records, grouped by appFees[].recipient
    -- dollars = sum(amountInUsd * fee / 10000) per recipient, successful swaps only

    From lunch money

    fees partner fees per day
    last 30 days
    Query
    -- three full days counted per month (the 5th, 15th and 25th), then the daily average of the window
    -- same Explorer request and fee rule as "Who's paying?"

    The mix keeps rotating

    btc Bitcoin%#& Zcashusd stablecoin pairs;:+ the rest
    last 30 days
    Query
    -- share of each day's partner volume by group (groups as in "Who's paying?")
    -- three sampled days per month, so the path between them is not shown

    It breaks sometimes

    fail swaps refunded or failed, share of the day
    Query
    -- same Explorer request; per day:
    -- (count(status = REFUNDED) + count(status = FAILED)) / count(*)

    The part we can count

    swap partner swaps;:+/| the rest of official volume
    Query
    -- partner swaps: 2 * sum(amountInUsd) of successful swaps per day (Explorer API);
    --   doubled because the official figure counts both sides of a swap
    -- official:      api.llama.fi/summary/dexs/near-intents?dataType=dailyVolume
    -- official swap counts, for the same check by count: dune.com/queries/4374089

    The other side of the ledger

    ;:+/| official volume of the tokentoken partner swaps that touch itright: partner share · official volume
    Query
    -- official, per token and day: NEAR's saved query dune.com/queries/5157527
    select date_at, symbol, sum(cast(volume_amount_usd as double)) as volume_usd
    from dune.near.dataset_near_intents_metrics
    group by date_at, symbol
    
    -- ours: sum(amountInUsd) of successful partner swaps whose origin or destination asset is the token
    -- (Explorer API, pipeline/swaps.py). Both count a swap once for each of its two tokens.

    What the chain says

    near NEAR arriving in the three revenue wallets, per day
    Query
    -- NEAR archival RPC, no key. For the last block of each UTC day:
    query { request_type: "view_account", block_id: <block>, account_id: <wallet> }   -- three wallets
    block { block_id: <block> }.header.total_supply                                  -- net new NEAR per day
    
    -- wallets: fefundsadmin.sputnik-dao.near, 1csfundsadmin.sputnik-dao.near, buybacks.multisignature.near
    -- code: pipeline/history.py      the same thing in SQL: dune.com/queries/6740088 (a third party's)

    A meter nobody publishes

    bytes new contract state per day
    Query
    -- NEAR archival RPC, no key. For the last block of each UTC day:
    query { request_type: "view_account", block_id: <block>, account_id: "intents.near" }.storage_usage
    
    -- the day's growth in bytes the contract stores: new accounts, keys, balances and intents
    -- code: pipeline/history.py

    What happened on those days

    Charts jump on particular days. The middle column is measured by the build. The right column is what a public source says, with its link; we did not measure it, and where we found nothing we say so.

    DateWhat our data showsWhat was announced

    The neighbours

    near NEAR Intents, one side of each swapvenue other venues, as DefiLlama reports them
    Query
    GET api.llama.fi/summary/dexs/{thorchain-dex, chainflip-amm, maya-protocol, near-intents}?dataType=dailyVolume
    -- summed over the same days. NEAR Intents is halved, because its figure counts both sides of a swap
    -- (see "The other side of the ledger"). The others are shown as reported; we did not audit their basis.

    What's the trade?

    of new NEAR issued, in dollars

    revenue a year · issued a year
    all NEAR at today's price is a year of that revenue

    Query
    revenue  = (revenue_now - cut_now * partner_fees) * growth
             + cut * partner_fees * growth
             + rest_bps / 10000 * (official_volume / 2 - partner_volume) * growth
    issuance = net new NEAR in the window * price * (cap / 2.5%)
    covered  = revenue / issuance
    
    -- run it yourself:  python3 -m pipeline.model --cut 0.5 --growth 2 --cap 0.016
    
    -- total_supply:        RPC block(final).header.total_supply
    -- max_inflation_rate:  RPC EXPERIMENTAL_protocol_config
    -- revenue_now:         api.llama.fi/summary/fees/near-intents?dataType=dailyRevenue
    -- wallets:             RPC view_account now and 30 days earlier (archival node)
    -- code: pipeline/model.py, pipeline/chain.py

    The bear case

    Evidence against.

      What would change our mind

        Every line gets re-tested on each build.

        Checks