Migliori e peggiori mille dollari di giugno 2026

Qual è stata la migliore operazione su opzioni di giugno 2026 — e cosa sarebbe diventato un investimento di mille dollari? La risposta onesta si articola in quattro punti: il jackpot; l'anomalo penny print di due contratti su cui si basa il titolo; i nove mila casi di perdite quasi totali registrati intorno ad esso; e la operazione speculare — VENDERE ciò che ha acquistato il vincitore — dove mille dollari di premio incassato sono diventati un buco a sei cifre. Tutto è calcolato EX POST dai dati storici; un trade ottimale a posteriori misura ciò che il mese ha contenuto, non una strategia che chiunque avrebbe potuto eseguire. Ogni numero è il risultato di una query memorizzata; espandere ogni pannello per visualizzare l'esatta SQL.

Quanto è stato volatile il mese di giugno 2026?

Un vincitore di opzioni con un rendimento di cento volte ha bisogno di un mese di mercato storico? Giugno dimostra di no. Il panel ricalcola ogni mese del 2026 nello stesso modo — dall'apertura alla chiusura durante l'orario regolare, più l'intervallo tra massimo e minimo come percentuale dell'apertura — per SPY e NVDA, le basi del titolo vincente. Giugno ha registrato 21 sessioni.

SELECT toString(toStartOfMonth(toDate(toTimeZone(window_start, 'America/New_York')))) AS period_start,
    round((argMaxIf(toFloat64(close), window_start, ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) / argMinIf(toFloat64(open), window_start, ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - 1) * 100, 1) AS spy_month_pct,
    round((maxIf(toFloat64(high), ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - minIf(toFloat64(low), ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959)) / argMinIf(toFloat64(open), window_start, ticker = 'SPY' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) * 100, 1) AS spy_range_pct,
    round((argMaxIf(toFloat64(close), window_start, ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) / argMinIf(toFloat64(open), window_start, ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - 1) * 100, 1) AS nvda_month_pct,
    round((maxIf(toFloat64(high), ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) - minIf(toFloat64(low), ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959)) / argMinIf(toFloat64(open), window_start, ticker = 'NVDA' AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60 + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959) * 100, 1) AS nvda_range_pct,
    uniqExactIf(toDate(toTimeZone(window_start, 'America/New_York')), ticker = 'SPY') AS trading_days
FROM global_markets.delayed_stocks_minute_aggs
WHERE ticker IN ('SPY', 'NVDA')
  AND window_start >= toDateTime('2026-01-01 05:00:00') AND window_start < toDateTime('2026-07-01 04:00:00')
GROUP BY period_start
HAVING uniqExactIf(toDate(toTimeZone(window_start, 'America/New_York')), ticker = 'SPY') >= 17
ORDER BY period_start ASC

SPY ha chiuso giugno a -1.2% dalla sua apertura all'interno di un range del 5.8% — più stretto rispetto a marzo (8.7%) o aprile (11.4%). L'attività si è spostata su un livello inferiore: NVDA ha chiuso a -7.4% dalla sua apertura di giugno dopo aver percorso un range del 19.7% (il riepilogo del mercato di giugno 2026 contiene il quadro completo del mercato). Un titolo con rendimento di cento volte non ha avuto bisogno di un mese di crash — il forte calo di un singolo titolo in due settimane è stato sufficiente.

I multipli più elevati del mese

L'universo: ogni contratto su sei titoli liquidi con almeno cinquanta scambi a giugno — 30951 contratti — con prezzo dal primo print del primo giugno all'ultimo, da entrambi i lati: quanto l'acquisto al primo prezzo sia diventato al valore dell'ultimo, e quanto la vendita per mille dollari di premio abbia generato una perdita.

SELECT ticker AS contract,
    substring(ticker, -9, 1) = 'P' AS is_put,
    round(first_px, 2) AS first_price,
    round(last_px, 2) AS last_price,
    round(last_px / first_px, 1) AS multiple,
    toUInt32(floor(1000 / (first_px * 100))) AS contracts_for_a_thousand,
    round(floor(1000 / (first_px * 100)) * last_px * 100, 0) AS bought_end_value_usd,
    round(1000 * (last_px / first_px) - 1000, 0) AS sold_net_loss_usd,
    trades
FROM (
    SELECT ticker,
        toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
        toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
        count() AS trades
    FROM global_markets.options_trades
    WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
    GROUP BY ticker
    HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)
ORDER BY multiple DESC, contract ASC
LIMIT 5

Il vincitore è stato un put: O:NVDA260629P00200000, con primo print a $0.01 e ultimo print a $4.95 — un multiplo di 495x. Analisi del simbolo: un put su NVDA con strike a $200 in scadenza il 29 giugno. Mille dollari al primo print hanno acquistato 1000 contratti; all'ultimo print la posizione segnava $495000. NVDA ha registrato un calo nella seconda metà di giugno — il suo crollo riporta la discesa, sessione per sessione — e questo contratto ha rappresentato quel calo, con leva finanziaria. Prevedere tali movimenti non è possibile; la sezione sottostante analizza il primo print.

Altri contratti in classifica

Tutti e cinque i contratti sono put — la colonna is_put riporta i dati — e anche il multiplo più basso ha superato dieci volte il valore iniziale. La seconda riga, un put su AAPL con strike a $240 in scadenza il 24 luglio, è passata da $0.01 a $0.34 con un multiplo di 34x ed era ancora attiva a fine mese (una scadenza a luglio rende l'ultimo prezzo un valore di mercato, non un settlement). La terza riga, un put su MU con strike a $100 in scadenza il 10 luglio, ha registrato un multiplo di 20x ed è proseguita anche a luglio. Le righe quattro e cinque, rispettivamente un put su TSLA con strike a $397.50 e un put su QQQ con strike a $707, entrambi in scadenza il 10 giugno, hanno generato multipli di 12.5x e 11.7x durante il calo iniziale del mese. Cinque contratti, cinque scommesse su un ribasso.

Vendere: come mille dollari diventano meno di mezzo milione

L'acquisto del winner comportava un rischio di esattamente mille dollari. VENDERLO — incassando quegli stessi mille dollari come premium — significava rischiare l'intero movimento. La colonna sold_net_loss_usd analizza ogni riga dal punto di vista del seller, ignorando margin, assignment e buy-in forzati. La vendita di 1000 contratti a $0.01 ha generato un incasso di mille dollari; l'ultima quotazione ha segnato la posizione a $495000 per il seller — una perdita netta di $494,000. Il caso peggiore per il buyer è il prezzo del ticket; il caso peggiore per il seller è il movimento, e il maggior movimento di giugno è stato profondo cinquecento ticket.

Il problema del penny print

Da dove proviene il 495x? La ricevuta qui sotto comprime l'intero tape di giugno del vincitore in un'unica riga forense: la sua prima esecuzione, la seconda e un censimento di ogni penny print della sua storia.

SELECT
    toString(toDate(min(sip_timestamp))) AS first_print_date,
    formatDateTime(toTimeZone(min(sip_timestamp), 'America/New_York'), '%H:%i:%S') AS first_print_et,
    round(anyIf(price, rn = 1), 2) AS first_price,
    toUInt64(anyIf(size, rn = 1)) AS first_print_contracts,
    countIf(price <= 0.011) AS penny_prints_in_june,
    toUInt64(sumIf(size, price <= 0.011)) AS penny_contracts_in_june,
    round(anyIf(price, rn = 2), 2) AS second_price,
    toUInt32(dateDiff('second', min(sip_timestamp), anyIf(sip_timestamp, rn = 2))) AS seconds_to_second_print,
    round(argMax(price, (sip_timestamp, price)), 2) AS month_last_price,
    round(argMax(price, (sip_timestamp, price)) / anyIf(price, rn = 2), 1) AS second_print_multiple_to_last,
    round(floor(1000 / (anyIf(price, rn = 2) * 100)) * argMax(price, (sip_timestamp, price)) * 100, 0) AS thousand_at_second_print_end_usd
FROM (
    SELECT sip_timestamp, toFloat64(price) AS price, size,
        row_number() OVER (ORDER BY sip_timestamp, price) AS rn
    FROM global_markets.options_trades
    WHERE ticker = 'O:NVDA260629P00200000'
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
)

Il contratto non era presente sul tape di giugno fino al 2026-06-15. La sua prima esecuzione, alle 09:49:30 ET, è stata di 2 contracts a $0.01 — circa due dollari di premium. L'esecuzione successiva, 101 secondi dopo, è stata di $2.44, e il penny non è mai più stato stampato (1 penny print, 2 contracts, in tutto il mese). La posizione da mille contract ipotizzata dal titolo è cinquecento volte superiore alla dimensione massima mai scambiata a quel prezzo. Entrando invece alla seconda esecuzione, mille dollari sarebbero diventati $1980 alla chiusura del mese — un 2x, non un 495x. Il rendimento dalla seconda esecuzione — circa il doppio in due settimane, con un percorso violento — era reale e scambiabile. Il jackpot, così come stampato, non lo era.

L'andamento: dieci sessioni dall'listing all'expiry

Assumendo l'esecuzione dell'impossibile, mantenere la posizione fino alla fine: ogni sessione sono stati registrati il turnover, l'ultimo prezzo e il mark della posizione.

WITH (
    SELECT (ticker, first_px)
    FROM (
    SELECT ticker,
        toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
        toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
        count() AS trades
    FROM global_markets.options_trades
    WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
    GROUP BY ticker
    HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
    )
    ORDER BY last_px / first_px DESC, ticker ASC
    LIMIT 1
) AS winner
SELECT toDate(sip_timestamp) AS date,
    toUInt64(sum(size)) AS contracts_traded,
    round(sum(toFloat64(price) * toFloat64(size)) * 100 / 1e6, 2) AS day_premium_usd_m,
    round(toFloat64(argMax(price, (sip_timestamp, price))), 2) AS day_last_price,
    round(floor(1000 / (winner.2 * 100)) * toFloat64(argMax(price, (sip_timestamp, price))) * 100, 0) AS position_value_usd,
    round(100 * toFloat64(argMax(price, (sip_timestamp, price))) / max(toFloat64(argMax(price, (sip_timestamp, price)))) OVER (), 1) AS pct_of_peak
FROM global_markets.options_trades
WHERE ticker = winner.1
  AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
GROUP BY date
ORDER BY date ASC

Il contratto è stato scambiato in tutte le 10 sessioni della sua vita, da 2026-06-15 fino all'expiry in 2026-06-29. Il primo giorno si è concluso a $1.4, con un mark di mille dollari già registrato a $140000 rispetto al prezzo di ingresso. Successivamente l'andamento è cambiato: un mark di $287000 in 2026-06-17 è sceso a $106000 entro 2026-06-22, con un drawdown di quasi due terzi. Il picco, $745000, è stato raggiunto in 2026-06-26, una sessione prima dell'expiry; il valore finale è stato di $495000 — 66.4% del picco. Anche la migliore operazione del mese si è conclusa con un terzo in meno rispetto al proprio massimo. Turnover: il primo giorno sono stati scambiati 385 contratti durante l'intera sessione — circa la posizione ipotizzata sommando le prime tre sessioni — mentre il giorno con più attività, 2026-06-23, ha registrato 9718 contratti e $2.86 milioni di premium. La dimensione degli ordini è emersa solo dopo l'inizio del movimento.

L'altro lato del bilancio

SELECT
    count() AS contracts_with_50_trades,
    countIf(substring(ticker, -9, 1) = 'P') AS put_contracts,
    countIf(last_px / first_px >= 100) AS up_100x_plus,
    countIf(last_px / first_px >= 10) AS up_10x_plus,
    countIf(last_px / first_px >= 10 AND substring(ticker, -9, 1) = 'P') AS up_10x_puts,
    countIf(last_px / first_px >= 10 AND substring(ticker, -9, 1) = 'C') AS up_10x_calls,
    countIf(last_px / first_px <= 0.1) AS down_90_pct_plus,
    countIf(last_px / first_px <= 0.1 AND substring(ticker, -9, 1) = 'C') AS down_90_calls,
    round(100.0 * countIf(last_px / first_px <= 0.1 AND substring(ticker, -9, 1) = 'C') / countIf(last_px / first_px <= 0.1), 1) AS down_90_call_share_pct,
    countIf(last_px <= 0.02) AS ended_at_two_cents_or_less
FROM (
    SELECT ticker,
        toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
        toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
        count() AS trades
    FROM global_markets.options_trades
    WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
    GROUP BY ticker
    HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)

SELECT ticker AS contract,
    round(first_px, 2) AS first_price,
    round(last_px, 2) AS last_price,
    toUInt32(floor(1000 / (first_px * 100))) AS contracts_a_thousand_bought,
    round(floor(1000 / (first_px * 100)) * last_px * 100, 0) AS ending_value_usd
FROM (
    SELECT ticker,
        toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
        toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
        count() AS trades
    FROM global_markets.options_trades
    WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
    GROUP BY ticker
    HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)
WHERE last_px <= 0.02 AND floor(1000 / (first_px * 100)) >= 1
ORDER BY first_px DESC, contract ASC
LIMIT 1

Il dato relativo al jackpot è il seguente: su 30951 contratti liquidi, esattamente 1 hanno registrato un rendimento di cento volte il capitale — e 9385 hanno perso il novanta per cento o più, con 8949 contratti nell'intero universo che hanno chiuso a due centesimi o meno. Pesca casuale da questo mazzo: il gruppo con perdite del novanta per cento è apparso migliaia di volte per ogni jackpot. La perdita più costosa è stata O:MU260612C01350000, una call MU con strike a $1,350 in scadenza il 12 giugno, aperta a giugno a $10 e conclusa a $0.01, trasformando mille dollari in $1.

Call o put: quale lato ha vinto?

I due estremi non coincidono. Il lato vincente è stato composto esclusivamente da put: ognuna delle 14 ten-baggers era una put (14 put, 0 call) in un universo che conteneva 14994 put su 30951 contratti. Il lato perdente era quasi equilibrato: delle 9385 perdite quasi totali, 4403 — 46.9% — erano call, con una leggera maggioranza di put. La direzione ha individuato ogni grande vincitore, ma non ha salvato nessuno da sola: migliaia di put sono finite anch'esse nel gruppo delle perdite, a causa di uno strike errato, di una settimana errata o di entrambi.

Dove si sono accumulate le perdite

Quale sottostante ha alimentato il cimitero? Non il titolo del crash.

SELECT
    multiIf(startsWith(ticker, 'O:NVDA'), 'NVDA', startsWith(ticker, 'O:TSLA'), 'TSLA', startsWith(ticker, 'O:AAPL'), 'AAPL', startsWith(ticker, 'O:SPY'), 'SPY', startsWith(ticker, 'O:QQQ'), 'QQQ', 'MU') AS root,
    count() AS contracts,
    countIf(last_px / first_px <= 0.1) AS down_90_pct_plus,
    round(100.0 * countIf(last_px / first_px <= 0.1) / count(), 1) AS pct_of_root_wiped,
    round(100.0 * countIf(last_px / first_px <= 0.1) / sum(countIf(last_px / first_px <= 0.1)) OVER (), 1) AS share_of_all_down_90_pct,
    countIf(last_px / first_px >= 10) AS up_10x_plus
FROM (
    SELECT ticker,
        toFloat64(argMin(price, (sip_timestamp, price))) AS first_px,
        toFloat64(argMax(price, (sip_timestamp, price))) AS last_px,
        count() AS trades
    FROM global_markets.options_trades
    WHERE ((startsWith(ticker, 'O:MU') AND length(ticker) = 19) OR (startsWith(ticker, 'O:NVDA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:TSLA') AND length(ticker) = 21) OR (startsWith(ticker, 'O:SPY') AND length(ticker) = 20) OR (startsWith(ticker, 'O:QQQ') AND length(ticker) = 20) OR (startsWith(ticker, 'O:AAPL') AND length(ticker) = 21))
      AND sip_timestamp >= toDateTime64('2026-06-01 00:00:00', 9) AND sip_timestamp < toDateTime64('2026-07-01 00:00:00', 9)
    GROUP BY ticker
    HAVING count() >= 50 AND argMin(price, (sip_timestamp, price)) > 0
)
GROUP BY root
ORDER BY down_90_pct_plus DESC, root ASC

QQQ ha fornito il gruppo più numeroso: 2923 perdite quasi totali — 31.1% dell'intero gruppo — con 35.7% dei suoi contratti liquidi azzerati. Aggiungendo il 24.7% di SPY, le radici dell'indice detengono oltre la metà del cimitero. I due tassi di azzeramento più bassi appartengono a NVDA e AAPL (21.8% e 21.8%) — il primo di questi è NVDA, la radice sotto il maggior vincitore del mese. Il gruppo è cresciuto maggiormente dove il premium è rimasto stabile. Il lato opposto, sulla stessa tabella: QQQ ha prodotto 9 delle 14 ten-baggers del mese; SPY, con 2319 contratti nel gruppo, ne ha prodotte 0.

Cosa insegna questa tabella (e cosa non può insegnare)

Quattro lezioni. La convexity è reale: un'opzione out-of-the-money economica aumenta di valore in modo esponenziale quando l'underlying si muove rapidamente — è esattamente il motivo per cui i biglietti della lotteria si scambiano a pochi centesimi. I multipli dei titoli principali richiedono un'analisi approfondita: il valore di 495x di giugno si basa su un'unica operazione da due lotti; il rendimento scambiabile era del doppio. La distribuzione è il prezzo della convexity: 14 titoli con rendimenti di dieci volte l'investimento si trovano accanto a 9385 perdite quasi totali (la spiegazione per i market makers approfondisce chi vende i biglietti). E il passato non può essere scambiato: il biglietto vincente non esisteva il 1° giugno — è stato emesso solo il 15 giugno — e acquistarlo significava conoscere, quella mattina, la direzione e il timing delle due settimane successive. Questa pagina misura il contenuto di giugno. Non suggerisce cosa accadrà a luglio.

FAQ

Qual è stata la migliore operazione su opzioni di giugno 2026?

Misurando il primo prezzo rispetto all'ultimo su sei asset liquidi, una put su NVDA con strike a $200 in scadenza il 29 giugno 2026: da $0.01 a $4.95, un multiplo di 495x — basata su un primo prezzo di un penny per due lotti (il prezzo successivo era $2.44).

È possibile perdere più di quanto investito facendo trading di opzioni?

Acquistando opzioni, no: un acquirente può perdere al massimo il premio pagato. Vendendo opzioni, sì — i dati di giugno mostrano un venditore che ha incassato mille dollari di premio e si è ritrovato con una posizione in perdita di $494,000 all'ultimo prezzo.

Perché la maggior parte delle opzioni economiche scade senza valore?

Un'opzione economica prezza un evento che il mercato considera improbabile: un movimento significativo prima di una scadenza imminente. La maggior parte dei mesi non presenta tali movimenti e la maggior parte dei titoli subisce il decadimento temporale. A giugno 2026, il 9385 di 30951 dei contratti scambiati ha perso almeno il novanta percento del valore del primo prezzo; il 8949 è stato scambiato l'ultima volta a due centesimi o meno.

Un trader reale avrebbe potuto catturare il 495x?

Quasi certamente no con la dimensione stampata: solo 2 contratti sono stati scambiati al prezzo di ingresso di $0.01, e il prezzo era a $2.44 entro 101 secondi. Mille dollari al secondo prezzo sono diventati circa $1980 all'ultimo prezzo — un trade eccellente, un multiplo che cambia la vita solo a posteriori.

Note sui dati

Metodologia

• Periodo: 1–30 giugno 2026; timestamp memorizzati in UTC, filtrati con limiti UTC grezzi. Il pannello di calibrazione è il blocco di base e analizza deliberatamente l'intero 2026, calcolato in modo identico.
• Per contratto: primo prezzo = l'operazione con il timestamp SIP più precoce di giugno, l'ultimo = il più tardivo; i pareggi sono risolti deterministicamente tramite il prezzo. I multipli sono calcolati tramite l'ultimo rispetto al primo, tramite query.
• Il pannello daily-path ricalcola il vincitore dallo stesso scan classificato ad ogni generazione; la ricevuta di ingresso lo fissa per simbolo, con limiti che mantengono il post se i due divergono.
• La generazione avviene solo tramite batch attraverso il percorso gated read-only; la pagina non interroga mai dati live. Stato del warehouse al 12 luglio 2026.

Ogni pannello è un singolo oggetto memorizzato — grafico, tabella e SQL. Interrogate il ledger direttamente sul terminale Strasmore.