On-chain data

Tokenized Stock Volume Fell 54% on a Closed Weekend and 11 Tokens Still Filled $10k Within 1% of the Share

Across 24 hours of a closed weekend, 24-hour volume in 25 tokenized stocks on Solana fell 54% while reported liquidity stayed at $28.4M. 11 of the 25 filled every $10,000 test buy within 1% of the real share. The script to record your own weekend is included.

By

You already know what a weekend does to a stock. The exchange is shut, the price on your app stops moving, and any order you place waits for Monday. A tokenized stock is a token on Solana that tracks a real share, and it does not wait. You can buy it on a Saturday night. So the fair question is what that buy costs you while the real market is closed.

The usual answer is that weekend markets are thin, so you pay up. We measured it. chaotic.markets saves a reading for every tokenized stock it lists, once every 5 minutes, and each reading holds a live quote for a large test buy. Below is one full day of those readings from a weekend when US exchanges were closed the whole time. Across 24 hours from the morning of Saturday 10 October 2026, 11 of 25 tokenized stocks on Solana filled every $10,000 test buy within 1% of the real share, while their volume fell 54%.

Key findings

What was measured

The window
Start 05:35 UTC, Saturday 10 October 2026
End 05:35 UTC, Sunday 11 October 2026
Tokens 25
Passes, one every 5 minutes 289
Passes where no quote came back 16
Passes saved before decimals were kept 3
Passes with a price paid 270

The recorder ran every five minutes through the window and missed none. The list is the stock and ETF tokens on chaotic.markets. Every pass that carried a session status showed the real exchange as closed.

Volume and liquidity are the figures Jupiter reports for each token. Volume is buys plus sells over the last 24 hours. We pass the liquidity figure through as reported.

The price paid comes from a quote. You ask Jupiter what a buy of a fixed dollar size would return, and dollars in divided by tokens out is your price. We compare that price with the share price Jupiter’s asset API reports for the stock behind the token. That share price did not change once for any token in the 24 hours, which is what you expect from a closed exchange. It is the same check as in the $100 buy of tokenized silver, repeated every 5 minutes.

Some passes are left out of the price table further down. In a few of them no quote came back for any token. The first three were saved before the recorder kept each token’s decimals, and you need the decimals to turn a token count into a price.

Volume halved and the liquidity stayed

All 25 tokens Sat 05:35 Sun 05:35 Change
Volume, last 24 hours $49.16M $22.40M -54.4%
Trades, last 24 hours 514,899 300,946 -41.6%
Liquidity $28.37M $28.38M +0.03%
NVDAx and SPCXx share of volume 34.2% 55.5% +21.3 pts

Read the two volume figures carefully, because each one looks back a full day. The Saturday figure covers the 24 hours before Saturday morning, so it holds all of Friday’s US session. The Sunday figure covers 24 hours that sit fully inside the weekend. So the fall is from a day with an open exchange to a day without one.

Liquidity did not follow. In every pass the total stayed within about 2% of where it began. Volume counts the trades people made, liquidity counts what is sitting in the pools for the next trade, and over this weekend people traded less while the pools kept what they had. A pool quotes a price from what it holds, whether or not anyone traded in the last hour.

The fall was uneven across tokens. These are the six with the most volume in the second day, with the same two readings of 24-hour volume. Times are UTC.

Token Sat 05:35 Sun 05:35 Change
NVDAx $8.87M $6.29M -29.1%
SPCXx $7.97M $6.15M -22.8%
GOOGLx $12.78M $2.89M -77.4%
SPYx $4.69M $2.05M -56.3%
GLDx $1.88M $1.01M -46.5%
TSLAx $2.67M $1.00M -62.4%

NVDAx and SPCXx, the token for SpaceX, held most of their volume and ended up as more than half of the weekend total, the last row of the table above. GOOGLx had the most volume going in and lost about three quarters of it. Only one token on the list, MRNA, had more volume in the second day than in the first.

What a $10,000 buy paid

This is the size where a thin market shows, the same way large trades fail on a DEX. Each row is one token across the 24 hours. Median and highest are the price paid against the real share. The last column counts the quotes that paid within 1% of it, above or below.

Token Quotes Median Highest In 1%
GLDx 268 -0.03% +0.03% 268
SPYx 267 +0.09% +0.22% 267
MSFTx 270 -0.06% +0.25% 270
QQQx 269 +0.04% +0.27% 269
GOOGLx 270 +0.07% +0.32% 270
AAPLx 270 +0.37% +0.44% 270
METAx 270 +0.37% +0.55% 270
NVDAx 266 +0.45% +0.56% 266
AMZNx 270 +0.28% +0.60% 270
TSLAx 262 +0.12% +0.62% 262
SPCXx 270 +0.57% +1.00% 270
MSTRx 267 +0.48% +1.05% 258
MU 269 +0.64% +1.10% 265
HOOD 268 +0.25% +1.16% 253
AMD 267 +0.75% +1.37% 214
SNDK 268 +0.85% +1.53% 172
LLY 270 +0.34% +1.57% 210
MRNA 269 +1.42% +2.37% 72
INTC 268 +0.76% +2.80% 243
MRVL 269 +0.99% +9.66% 139
SKHY 267 +0.72% +72.84% 241

The first eleven rows never left the 1% line. For those tokens a large weekend buy paid about what the share was last worth, in every quote we have. The next ten had a market all day and still went past 1% at least once.

Two of those ten show why you check the quote at the moment you trade. MRVL sat near the line for most of the day, and six of its quotes came back between 7% and 10% over the share. SKHY paid well inside the line in most quotes, and two quotes on Saturday evening came back at the figure in the table. In those same two passes a small SKHY buy paid less than one percent over the share.

A small buy was easier in general. On a $100 buy, 17 of these 21 tokens stayed inside 1% in every quote.

The liquidity figure does not rank these tokens for you. Take two of them.

Token Reported liquidity Quotes within 1%
AMZNx $0.36M to $0.38M 270 of 270
SKHY $1.68M to $1.73M 241 of 267

Four tokens are missing from the big table because they had no usable market at this size.

Token What a $10,000 quote returned
VOOx no route in any pass
NFLXx 17.06% to 17.16% over the share
SLVx no usable market
IJRx no usable market

SLVx and IJRx are priced far from their shares, which the earlier article covers.

One caution on reading the gap. The price paid against the share holds two things, the cost of your size and whatever the market thinks the share will do on Monday. One weekend cannot separate them, and we make no claim about which is which. This is also one weekend, so it says nothing yet about how other weekends go.

Run it yourself

You need Python 3.9 or newer. There is nothing to install and no key to set. Save this as weekend_watch.py.

"""Record what a $10,000 buy of each tokenized stock costs against the real share.

record   one pass every few minutes, appended to weekend.csv
summary  what the saved passes show, token by token
"""

from __future__ import annotations

import csv
import json
import statistics
import sys
import time
import urllib.request
from datetime import datetime, timezone
from pathlib import Path

USDC = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
ASSETS_URL = "https://datapi.jup.ag/v1/assets/search?query="
QUOTE_URL = "https://lite-api.jup.ag/swap/v1/quote"
SIZE = 10_000  # USD per test buy
LOG = Path("weekend.csv")
FIELDS = ("ts", "token", "share", "volume_24h", "liquidity", "vs_share")

TOKENS: dict[str, str] = {
    "NVDAx": "Xsc9qvGR1efVDFGLrVsmkzv3qi45LTBjeUKSPmx9qEh",
    "TSLAx": "XsDoVfqeBukxuZHWhdvWHBhgEHjGNst4MLodqsJHzoB",
    "AAPLx": "XsbEhLAtcf6HdfpFZ5xEMdqW8nfAvcsP5bdudRLJzJp",
    "MSFTx": "XspzcW1PRtgf6Wj92HCiZdjzKCyFekVD8P5Ueh3dRMX",
    "AMZNx": "Xs3eBt7uRfJX8QUs4suhyU8p2M6DoUDrJyWBa8LLZsg",
    "GOOGLx": "XsCPL9dNWBMvFtTmwcCA5v3xWPSMEBCszbQdiLLq6aN",
    "METAx": "Xsa62P5mvPszXL1krVUnU5ar38bBSVcWAB6fmPCo5Zu",
    "MSTRx": "XsP7xzNPvEHS1m6qfanPUGjNmdnmsLKEoNAnHjdxxyZ",
    "SPYx": "XsoCS1TfEyfFhfvj8EtZ528L3CaKBDBRqRapnBbDF2W",
    "QQQx": "Xs8S1uUs1zvS2p7iwtsG3b6fkhpvmwz4GYU3gWAmWHZ",
    "SPCXx": "Xs3oZwbHvqis4NYcf4YKWmEia2eC84wSiVrcYcTqpH8",
    "VOOx": "Xsd7TduTbjuYCFL7Uoujb8SbkZLmUsuYNLn7KdvX21x",
    "IJRx": "XsyZcb97BzETAqi9BoP2C9D196MiMNBisGMVNje2Thz",
    "GLDx": "Xsv9hRk1z5ystj9MhnA7Lq4vjSsLwzL2nxrwmwtD3re",
    "SLVx": "XsxAd6okt8y1RRK6gNg7iJaqiWNiq5Md5EDf3ZrF2dm",
    "NFLXx": "XsEH7wWfJJu2ZT3UCFeVfALnVA6CP5ur7Ee11KmzVpL",
    "MRNA": "MRNAzXzhNcaEXJPibHEn8cd4vyekCDiivTyEwswLUCT",
    "LLY": "LLYuwZ33keFihgwoxXsBawy31AiRFLFSva32TYq5TvD",
    "MU": "MUxEsUKSMACyw5fZf68wxf5FLnZVhtU9CwH8uNNGay1",
    "INTC": "iNTCy1qTsUEZQe3DSocLz1ZXXai34Gdw8THQh5rxFaF",
    "AMD": "AMD8XwJXgQ9WV45Wyj9yFLejxzf2J6VM1PJY8bJEjeES",
    "MRVL": "MRVLSjkR2ceUBukujaD3xCyHP1H3B2SzpsNTZF546jo",
    "SNDK": "SNDKbwMUQvZhnLnxLduradgLHG5KrPuKwpnrkkGRhfH",
    "SKHY": "SKHYhSjuRWHgikq8eRKbtBbpABgJSkd7ytQV14i9EQ3",
    "HOOD": "HooDYv5RewLRiMLnEVq3VJqdqxhuE6c5eYvqejMC3e9A",
}


def _get(url: str) -> object:
    """Fetch a URL and parse the JSON body. Returns None on any failure."""
    request = urllib.request.Request(url, headers={"User-Agent": "weekend-watch/1.0"})
    try:
        with urllib.request.urlopen(request, timeout=20) as response:
            return json.load(response)
    except Exception:
        return None


def _assets(mints: list[str]) -> dict[str, dict]:
    """One call for every token: share price, volume, liquidity, decimals."""
    rows = _get(ASSETS_URL + ",".join(mints)) or []
    return {row["id"]: row for row in rows if row.get("id") in mints}


def _quote(mint: str, usd: int) -> dict | None:
    """The quote Jupiter would fill for a buy of `usd` dollars of USDC."""
    url = (
        f"{QUOTE_URL}?inputMint={USDC}&outputMint={mint}"
        f"&amount={usd * 10**6}&slippageBps=100&restrictIntermediateTokens=true"
    )
    for pause in (0, 5):  # a rate-limited quote looks like no route, so ask twice
        time.sleep(pause)
        quote = _get(url)
        if isinstance(quote, dict) and "outAmount" in quote:
            return quote
    return None


def _vs_share(usd: int, quote: dict, asset: dict) -> float | None:
    """Price paid per share-equivalent against the real share, in percent."""
    share = (asset.get("stockData") or {}).get("price")
    raw_price = (asset.get("scaledUiConfig") or {}).get("usdPricePrescaled") or asset.get("usdPrice")
    if not share or not raw_price or not asset.get("usdPrice"):
        return None
    paid_raw = usd / (int(quote["outAmount"]) / 10 ** asset["decimals"])
    paid = paid_raw * asset["usdPrice"] / raw_price  # raw units to share units
    return (paid / share - 1) * 100


def _volume(asset: dict) -> float:
    """Buy plus sell volume over the last 24 hours, in dollars."""
    stats = asset.get("stats24h") or {}
    return (stats.get("buyVolume") or 0) + (stats.get("sellVolume") or 0)


def record(passes: int, wait: int) -> None:
    """Save `passes` passes to the log, one every `wait` seconds."""
    is_new = not LOG.exists()
    with LOG.open("a", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=FIELDS)
        if is_new:
            writer.writeheader()
        for n in range(passes):
            started = time.time()
            ts = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M")
            assets = _assets(list(TOKENS.values()))
            for symbol, mint in TOKENS.items():
                asset = assets.get(mint)
                if asset is None:
                    continue
                quote = _quote(mint, SIZE)
                time.sleep(1.1)  # the keyless tier allows about one request a second
                gap = _vs_share(SIZE, quote, asset) if quote else None
                writer.writerow(
                    {
                        "ts": ts,
                        "token": symbol,
                        "share": (asset.get("stockData") or {}).get("price") or "",
                        "volume_24h": round(_volume(asset)),
                        "liquidity": round(asset.get("liquidity") or 0),
                        "vs_share": "" if gap is None else round(gap, 4),
                    }
                )
            handle.flush()
            print(f"pass {n + 1} of {passes} saved, {ts} UTC")
            if n + 1 < passes:
                time.sleep(max(0.0, wait - (time.time() - started)))


def summary() -> None:
    """Print the totals at the first and last pass, then one line per token."""
    with LOG.open(newline="") as handle:
        rows = list(csv.DictReader(handle))
    stamps = sorted({row["ts"] for row in rows})
    for label, ts in (("first", stamps[0]), ("last", stamps[-1])):
        at = [row for row in rows if row["ts"] == ts]
        volume = sum(float(row["volume_24h"]) for row in at)
        liquidity = sum(float(row["liquidity"]) for row in at)
        print(f"{label:<5} {ts} UTC  volume ${volume:,.0f}  liquidity ${liquidity:,.0f}")
    print(f"\n{'token':<7} {'quotes':>6} {'median':>8} {'highest':>9} {'in 1%':>6}")
    for symbol in TOKENS:
        gaps = [float(row["vs_share"]) for row in rows if row["token"] == symbol and row["vs_share"]]
        if not gaps:
            print(f"{symbol:<7} {'none':>6}")
            continue
        inside = sum(abs(gap) <= 1 for gap in gaps)
        print(f"{symbol:<7} {len(gaps):>6} {statistics.median(gaps):>+7.2f}% {max(gaps):>+8.2f}% {inside:>6}")


def main() -> None:
    if len(sys.argv) > 1 and sys.argv[1] == "summary":
        summary()
        return
    passes = int(sys.argv[2]) if len(sys.argv) > 2 else 12
    wait = int(sys.argv[3]) if len(sys.argv) > 3 else 300
    record(passes, wait)


if __name__ == "__main__":
    main()

Start with a short run, three passes that begin two minutes apart. It takes about five minutes.

python3 weekend_watch.py record 3 120

We ran it on Sunday 11 October 2026, with the exchange still closed. It printed a line as each pass finished.

pass 1 of 3 saved, 2026-10-11 06:35 UTC
pass 2 of 3 saved, 2026-10-11 06:37 UTC
pass 3 of 3 saved, 2026-10-11 06:39 UTC

Each pass adds one line per token to weekend.csv. Now ask for the summary.

python3 weekend_watch.py summary
first 2026-10-11 06:35 UTC  volume $22,787,274  liquidity $28,266,786
last  2026-10-11 06:39 UTC  volume $22,827,307  liquidity $28,279,776

token   quotes   median   highest  in 1%
NVDAx        3   +0.43%    +0.43%      3
TSLAx        3   -0.11%    +0.29%      3
AAPLx        3   +0.35%    +0.35%      3
MSFTx        3   -0.21%    +0.14%      3
AMZNx        3   +0.15%    +0.15%      3
GOOGLx       3   -0.22%    -0.21%      3
METAx        3   +0.33%    +0.33%      3
MSTRx        3   +0.34%    +0.39%      3
SPYx         3   -0.01%    -0.01%      3
QQQx         3   -0.04%    -0.04%      3
SPCXx        3   +0.66%    +0.66%      3
VOOx      none
IJRx         3 +2789039.60% +2789039.60%      0
GLDx         3   -0.07%    -0.07%      3
SLVx         3 +1974.82% +1974.82%      0
NFLXx        3  +17.06%   +17.06%      0
MRNA         3   -0.16%    -0.16%      3
LLY          3   +1.38%    +1.39%      1
MU           3   +0.58%    +0.98%      3
INTC         3   +2.68%    +2.68%      1
AMD          3   +0.71%    +0.72%      3
MRVL         3   +0.60%    +0.60%      3
SNDK         3   +0.51%    +0.54%      3
SKHY         3   +0.54%    +0.54%      3
HOOD         3   +0.20%    +0.21%      3

VOOx shows none because no route came back. IJRx, SLVx and NFLXx are the tokens with no usable market at this size, the same ones as in the article’s table. A quote that fails is asked for once more after five seconds, and if it fails again that row is left blank and is not counted. This happens on the keyless quote API. One of our earlier test runs lost most of a pass to 503 answers, and the recorder’s own window has passes with no quote too.

Your numbers will be different, because prices and pools move. To cover a full day the way the recorder does, ask for 288 passes that begin five minutes apart, and leave it running.

python3 weekend_watch.py record 288 300

Run the summary at any point while it records. The first two lines give you the volume and liquidity totals at your first and last pass, so you can see the weekend fall for yourself.

Where to see the live numbers

The chaotic.markets data page shows the price against the share, the volume and the cost of size for every token, from a reading saved every 5 minutes. Each token has its own page, for example NVDAx and SKHY.

Buy on chaotic.markets

The liquidity page ranks every token by what a $10,000 buy costs right now, next to $100 and $1,000 buys, and every row has a Buy button. Press it, connect your Solana wallet, type the USDC amount and approve once. The tokens settle to your wallet and chaotic.markets never holds them. chaotic.markets adds no fee. You still pay the pool fees inside Jupiter’s route and the Solana network fee, plus any price over the share, which is the number in each row.

Newsletter

Get chaotic.markets updates and new data articles by email.

You confirm by email, and you can unsubscribe from any message. The list is kept by Kit.