Q2hlIGNvc1wnw6ggTVZSVj8gQ29tcHJlbmRlcmUgdW5hIG1ldHJpY2EgY2hpYXZlIHBlciBsYSB2YWx1dGF6aW9uZSBkZWdsaSBhc3NldCBjcnlwdG8=

<p><img src="https://gimg2.gateimg.com/image/mvrv202506271743221376627750.png" alt="">
</p><p>Nel mercato delle criptovalute altamente volatile, determinare quando un asset è sopravvalutato o sottovalutato è una delle principali sfide affrontate dagli investitori. Il rapporto MVRV (Market Value to Realized Value) è un indicatore on-chain chiave creato per affrontare questo problema. È stato introdotto per la prima volta dagli analisti Murad Mahmudov e David Puell nel 2018 ed è diventato da allora uno strumento standard del settore per misurare i livelli di valutazione degli asset criptovalutari come Bitcoin.</p>
<h2 id="h2-Principio20fondamentale20di20MVRV20Valore20di20mercato20vs20Costo20reale605075"><a name="Principio fondamentale di MVRV: Valore di mercato vs. Costo reale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Principio fondamentale di MVRV: Valore di mercato vs. Costo reale</h2><p>Comprendere l’MVRV richiede di suddividere i suoi due componenti principali:</p>
<ul>
<li><p>Valore di Mercato (MV): Questa è la capitalizzazione di mercato nel senso tradizionale, calcolata come:</p>
<blockquote>
<p>Prezzo Corrente × Fornitura Circolante<br>Riflette il valore totale degli asset nel trading in tempo reale e fluttua significativamente con il sentiment di mercato.
</p></blockquote>
</li><li><p>Valore Realizzato (RV): Conosciuto anche come “valore di mercato effettivo”, il suo calcolo si basa sui dati on-chain della blockchain:</p>
<blockquote>
<p>∑ (prezzo all’ultima movimentazione on-chain di ciascun token × quantità)<br>Traccia il prezzo di mercato all’ultimo trasferimento di ciascun token e aggrega per derivare il costo medio di base dei possessori attraverso la rete. Ad esempio, se un <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è stato trasferito per l’ultima volta a $30,000, indipendentemente dal fatto che il prezzo attuale salga a $60,000 o scenda a $20,000, il suo contributo al RV rimane $30,000.</p>
</blockquote>
</li></ul>
<h3 id="h3-MVRV20Ratio2020MV2020RV88518"><a name="MVRV Ratio = MV / RV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MVRV Ratio = MV / RV</h3><p>Questo rapporto rivela un fatto fondamentale:</p>
<ul>
<li>Quando MVRV &gt; 1: Il prezzo di mercato è superiore al costo medio, gli investitori sono generalmente in profitto e la tendenza a vendere aumenta;</li><li>Quando MVRV &lt; 1: Il prezzo di mercato è inferiore al costo medio, gli investitori sono generalmente in perdita e potrebbe essere vicino al fondo del mercato.</li></ul>
<h3 id="h3-Perch20lMVRV2020pi20efficace20degli20indicatori20tradizionali305289"><a name="Perché l’MVRV è più efficace degli indicatori tradizionali?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché l’MVRV è più efficace degli indicatori tradizionali?</h3><p>A differenza di metriche tradizionali come il rapporto prezzo-utili, l’MVRV utilizza direttamente la trasparenza della blockchain per tracciare i costi reali. I suoi vantaggi includono:</p>
<ol>
<li>Filtraggio delle interferenze dei “token zombie”: Token persi o non movimentati a lungo termine (che rappresentano circa il 15% di Bitcoin) non gonfiano la stima del valore reale;</li><li>Riflettendo i giochi psicologici: I valori estremi della metrica spesso corrispondono a punti di svolta nelle emozioni di gruppo di “avidità” o “paura”, aderendo al principio di investimento di “essere avidi quando gli altri sono spaventati”;</li><li>Identificazione delle fasi del ciclo di mercato:<ul>
<li>Picco del mercato rialzista: MVRV &gt; 3 (ad esempio, raggiungendo 3.7 nel 2017, seguito da un crollo dell’80%);</li><li>Fondo del mercato ribassista: MVRV &lt; 1 (ad esempio, scendendo a 0.85 a marzo 2020, per poi rimbalzare del 600%).</li></ul>
</li></ol>
<h2 id="h2-Applicazioni20avanzate20di20MVRV20punteggio20Z20e20segmentazione20dei20detentori200794"><a name="Applicazioni avanzate di MVRV: punteggio Z e segmentazione dei detentori" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Applicazioni avanzate di MVRV: punteggio Z e segmentazione dei detentori</h2><p>Per migliorare l’accuratezza del giudizio, gli analisti hanno sviluppato un indicatore derivato dell’MVRV:</p>
<h3 id="h3-MVRVZ20Score557767"><a name="MVRV-Z Score" class="reference-link"></a><span class="header-link octicon octicon-link"></span>MVRV-Z Score</h3><p>Il concetto di deviazione standard dalla statistica è introdotto basato su MVRV per misurare l’estensione in cui il valore attuale si discosta dalla media storica. La sua importanza è:</p>
<ul>
<li>Z &gt; 6.9: Seriamente sopravvalutato, indicando rischio di vendita (accuratezza oltre il 94%);</li><li>Z &lt; 0: Seriamente sottovalutato, un’opportunità di acquisto sul lato sinistro (ad esempio, ritorno medio del 480% dopo aver acquistato durante il mercato ribassista del 2022).</li></ul>
<h3 id="h3-LTHMVRV20e20STHMVRV131273"><a name="LTH-MVRV e STH-MVRV" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LTH-MVRV e STH-MVRV</h3><p>Analisi stratificata per durata di detenzione:</p>
<ul>
<li>Detentori a lungo termine (LTH, &gt;155 giorni): Costo stabile, accumulano token quando il MVRV è basso;</li><li>Detentori a breve termine (STH, &lt;155 giorni): Costo vicino al prezzo attuale, notevole pressione di vendita quando il MVRV è alto.</li></ul>
<p>Questa classificazione può prevedere la direzione del “denaro intelligente”. Ad esempio, un aumento di LTH durante una fase di MVRV basso indica spesso la formazione di un minimo.</p>
<h2 id="h2-Caso20Pratico20Come20Guida20lMVRV20gli20Investimenti220340"><a name="Caso Pratico: Come Guida l’MVRV gli Investimenti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Caso Pratico: Come Guida l’MVRV gli Investimenti?</h2><h3 id="h3-Identificazione20del20Fondo20Prendendo20Bitcoin20come20Esempio611863"><a name="Identificazione del Fondo (Prendendo Bitcoin come Esempio)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Identificazione del Fondo (Prendendo <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> come Esempio)</h3><ul>
<li>Mercato Orso 2018: MVRV-Z è diventato negativo a novembre, rimanendo tale per 4 mesi, con un calo massimo del 28%, ma il rimbalzo dell’anno successivo ha ottenuto un ritorno del 250%;</li><li>Mercato Orso 2022: MVRV è sceso sotto 1, con l’MVRV di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> attorno a 0.9 nello stesso periodo, entrambi attivando segnali di acquisto.</li></ul>
<h3 id="h3-Avviso20principale71564"><a name="Avviso principale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Avviso principale</h3><ul>
<li>Mercato Toro 2021: MVRV-Z ha superato 7, la capitalizzazione di mercato di Bitcoin è crollata dopo aver raggiunto 3,7 trilioni di dollari;</li><li><a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a>(DOGE): Dopo che l’MVRV si è avvicinato a 1 nell’agosto 2024, è aumentato del 400%, mentre un MVRV elevato indica un rischio di correzione.</li></ul>
<h2 id="h2-Limitazioni20di20MVRV20e20Raccomandazioni20per20lUso318915"><a name="Limitazioni di MVRV e Raccomandazioni per l’Uso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Limitazioni di MVRV e Raccomandazioni per l’Uso</h2><p>Nonostante la sua potenza, l’MVRV non è una “chiave magica” e serve cautela:</p>
<ol>
<li>Punti ciechi temporali: La durata dei mercati orso/bull non può essere prevista (l’intervallo minimo può durare da 1 settimana a 1 anno);</li><li>Limitazioni di applicabilità: Più efficace per le monete principali con dati on-chain ricchi (BTC, ETH), meno valore di riferimento per le monete piccole;</li><li>Ottusità dell’indicatore: Man mano che l’uso diventa diffuso, il punto critico potrebbe fallire a causa di aspettative autoavveranti.</li></ol>
<p>Raccomandazioni sulle migliori pratiche:</p>
<ul>
<li>Combinare con altri indicatori: come SOPR (Spent Output Profit Ratio), flusso netto degli scambi, ecc. per convalidare i segnali;</li><li>Costruire posizioni a fasi: investire regolarmente per 6 - 12 mesi nella regione MVRV-Z &lt; 0 per ridurre il rischio di volatilità a breve termine;</li><li>Prospettiva a lungo termine: evitare di utilizzare per il trading a breve termine, concentrarsi sul timing ciclico.</li></ul>
<p>Il valore fondamentale di MVRV risiede nella quantificazione del sentiment di mercato in dati affidabili, penetrando nel rumore dei prezzi per rivelare il valore sottostante. Come afferma la società di analisi on-chain Glassnode: è il “termometro dei cicli di mercato.” Negli investimenti in criptovalute, piuttosto che inseguire le fluttuazioni a breve termine, è meglio utilizzare MVRV per ottenere informazioni sulla posizione del ciclo: quando l’indicatore entra nella zona verde sottovalutata, potrebbe essere il momento di “gli altri hanno paura, io sono avido.”</p>
<div class="blog-details-info"><br><div>Autore: <strong>Team Blog</strong><br><div class="info-tips"><em>Il contenuto qui non costituisce alcuna offerta, sollecitazione o raccomandazione. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare l'uso di tutti o di una parte dei Servizi da Località Riservate. Per ulteriori informazioni, si prega di leggere l'Accordo Utente tramite <a href="https://www.gate.com/legal/user-agreement" data-index="3">https://www.gate.com/legal/user-agreement</a>.<br><p></p><br></em></div></div></div>