Q2FyZGFubyAoQURBKSBUZXN0YSBpbCBzdXBwb3J0byBhICQwLjMwOiBSZXNpc3RlcsOgIGFsbGEgcHJlc3Npb25lPw==

2023-06-26, 09:49

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""></p>
<h2 id="h2-TL20DR360604"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Il prezzo di <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">criptovaluta Cardano</a> Il prezzo di (ADA) è diminuito del 10% dopo che la SEC l’ha designato come un titolo di sicurezza.</p>
<p>Molti detentori di ADA probabilmente smetteranno di venderlo se il prezzo rimane al di sotto di $0.30.</p>
<p>La maggior parte degli investitori che hanno acquistato ADA nel maggio 2023 potrebbero avere perdite non realizzate.</p>
<h2 id="h2-Introduzione663430"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La prima settimana di giugno è stata un periodo tumultuoso per l’industria delle criptovalute a causa dell’azione regolatoria della Securities and Exchange Commission (SEC) degli Stati Uniti contro le principali borse di criptovalute, Binance e Coinbase. Tale azione ha portato a gravi cali di prezzo di diverse criptovalute come <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> (ADA). In questo pezzo, discuteremo di come <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> è stato influenzato.</p>
<h2 id="h2-Il20prezzo20di20Cardano20scende20del201020dopo20essere20stato20designato20come20una20crypto20security971956"><a name="Il prezzo di Cardano scende del 10% dopo essere stato designato come una crypto security" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il prezzo di Cardano scende del 10% dopo essere stato designato come una crypto security</h2><p>L’elenco della Cardano da parte della SEC come titolo crittografico ha comportato un calo del 10% del suo prezzo. Fondamentalmente, i prezzi di molte criptovalute sono scesi mentre il mercato reagiva alla cattiva notizia. Tuttavia, Cardano è stata una delle criptovalute top 10 più colpite, anche se c’è la speranza che possa riprendersi man mano che le cose si stabilizzano.</p>
<p>Durante quel periodo il livello di supporto era a $0.30 mentre il livello di resistenza era a $0.33. Se <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">prezzo di Cardano</a> Se dovesse scendere sotto i $0,30, allora probabilmente $0,28 sarebbe il prossimo livello di supporto. D’altro canto, il ribasso attuale è stato avviato quando il prezzo ha toccato il livello di resistenza di $0,33.<br><img src="https://gimg2.gateimg.com/image/article/16877727583991687772517_.pic.jpg" alt=""><br>Grafico dei prezzi di Cardano - TradingView</p>
<p>Il diagramma sopra indica i possibili livelli di supporto e resistenza di Cardano in base alle sue precedenti prestazioni di prezzo. Nella prima settimana di giugno, il volume di trading di ADA era molto basso, il che ha fatto prevedere al mercato un aumento dell’appetito se il suo prezzo fosse sceso sotto i $0,30. Purtroppo, alla fine di quella settimana l’Indice di Forza Relativa di Cardano era 30, il che indicava un forte momento ribassista.</p>
<p>Tuttavia, l’indicatore MACD ha dato una visione promettente in quel momento. L’istogramma mostrava minimi più bassi, un’indicazione che il momentum di mercato di ADA si sarebbe ripreso nuovamente. C’è stata anche un’altra sviluppo significativo durante quel periodo. Secondo <a href="https://finbold.com/topic/blockchain/" rel="nofollow noopener noreferrer" target="_blank">IntoTheBlock</a>, secondo una società di intelligence blockchain, l’83% dei detentori di ADA, circa 3,67 milioni di indirizzi, è stato in rosso a causa di quel calo di mercato. Il seguente diagramma dipinge un quadro completo della situazione.<br><img src="https://gimg2.gateimg.com/image/article/16877727974001687772530_.pic.jpg" alt=""><br>I possessori di ADA in rosso - Finhold</p>
<p>Come si può notare dall’immagine, la maggior parte degli indirizzi del portafoglio ADA indica perdite.</p>
<h2 id="h2-I20possessori20di20Cardano20potrebbero20smettere20di20vendere370059"><a name="I possessori di Cardano potrebbero smettere di vendere" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I possessori di Cardano potrebbero smettere di vendere</h2><p>Secondo Santiment, il rapporto tra valore di mercato e valore realizzato mostra che la maggior parte dei detentori di criptovalute che hanno acquisito Cardano durante l’ultimo mese si trovano di fronte a una grande perdita non realizzata a causa del recente calo del prezzo di Cardano. In realtà, la maggior parte di loro ha approssimativamente il 13% di perdita non realizzata. Una così grande perdita potenziale può costringere la maggior parte degli investitori strategici di Cardano a smettere di venderlo.</p>
<p>La criptovaluta Cardano finora ha subito solo due forti cali di prezzo. Il suo prezzo è crollato di circa il 15%. <a href="https://www.gate.io/explore/ftx-sbf" target="_blank">dopo il collasso del FTX nel 2022</a> e dopo la disinnescatura di USDC all’inizio di quest’anno. Pertanto, se la maggior parte dei detentori di Cardano smette di vendere le loro posizioni ADA, potrebbe presto vivere un rimbalzo.</p>
<p>C’è un’altra indicazione che la maggior parte <a href="https://www.gate.io/uk/blog_detail/2210/cardano-ada-what-is-it-and-how-does-it-differ-from-bitcoin" target="_blank">Detentori di Cardano</a> potrebbe smettere di vendere se desiderano recuperare il loro investimento o se mirano a realizzare un profitto. C’è un graduale calo nell’ADA Age Consumed, il che indica che la maggior parte degli hodlers non è disposta a venderlo. Principalmente, l’Age Consumed è una metrica che valuta i sentimenti degli investitori a lungo termine moltiplicando il numero di monete trasferite di recente per il numero di giorni trascorsi dal momento in cui sono state spostate per l’ultima volta.</p>
<p>I dati recenti on-chain mostrano che la maggior parte degli investitori ha ridotto la quantità di ADA spostata quando il suo prezzo è sceso al di sotto di $0.35.</p>
<p>La netta diminuzione dell’ADA consumata indica che la maggior parte degli investitori di Cardano non è disposta a vendere l’asset crittografico. Il mercato si aspettava che la riduzione della pressione venditrice dell’ADA lo aiutasse a difendere il livello di resistenza di $0,30. Se si riprende dalla sua attuale diminuzione del prezzo dell’ADA, potrebbe raggiungere il livello di prezzo di $0,40.</p>
<h2 id="h2-Livello20attuale20del20prezzo20di20ADA20e20previsioni300628"><a name="Livello attuale del prezzo di ADA e previsioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Livello attuale del prezzo di ADA e previsioni</h2><p>Finora abbiamo analizzato le varie permutazioni del movimento del prezzo di ADA in base alle sue prestazioni di mercato durante la prima settimana di giugno. Ora, rivolgiamo la nostra attenzione alla sua direzione attuale del prezzo e al suo valore futuro stimato.</p>
<p>Al momento della scrittura, il prezzo di ADA è di $0.2680, dopo aver perso lo 0,1% nelle ultime 24 ore. Nel complesso, ha perso il 26,9% negli ultimi 14 giorni. Il seguente diagramma mostra che il prezzo di ADA è diminuito da $0.32 il 9 giugno a $0.24 il 10 giugno. Tuttavia, si è ripreso leggermente per chiudere la giornata a $0.27 l’11 giugno. Attualmente oscilla tra $0.26 e $0.28.</p>
<p>Leggi anche: <a href="https://www.gate.io/how-to-buy/cardano-ada" target="_blank">Come acquistare Cardano ADA su Gate.io</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/16877728914011687772552_.pic.jpg" alt=""><br>ADA’s 30 Day Performance di Prezzo - CoinGecko</p>
<p>Nonostante il trend al ribasso attuale di ADA, diversi analisti credono che il suo prezzo salirà presto a oltre $0,30 o addirittura raggiungerà $0,40 nei prossimi mesi.</p>
<h2 id="h2-Conclusione202032"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il prezzo di Cardano è sceso del 10% dopo il <a href="https://www.gate.io/ru/blog_detail/2448/cz-sued-by-cftu-another-turn-of-the-crypto-saga" target="_blank">La SEC ha citato in giudizio Binance</a> e Coinbase per aver violato le sue leggi sui titoli. Attualmente, il valore di ADA oscilla tra $0.26 e $0.28. Tuttavia, il mercato si aspetta un rimbalzo una volta risolte le questioni che interessano Binance e Coinbase.</p>
<h2 id="h2-Domande20frequenti20su20Cardano20ADA250690"><a name="Domande frequenti su Cardano (ADA)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti su Cardano (ADA)</h2><h3 id="h3-Perch20il20prezzo20di20ADA20sta20scendendo664646"><a name="Perché il prezzo di ADA sta scendendo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché il prezzo di ADA sta scendendo?</h3><p>Il prezzo di ADA sta scendendo perché la SEC lo ha designato come un titolo. Inoltre, la causa intentata dalla Securities and Exchange Commission (SEC) degli Stati Uniti contro gli exchange di Binance e Coinbase ha portato alla diminuzione dei valori di diverse criptovalute, tra cui ADA.</p>
<h3 id="h3-Perch20Cardano20sta20cadendo20cos20tanto369891"><a name="Perché Cardano sta cadendo così tanto?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché Cardano sta cadendo così tanto?</h3><p>Il prezzo di Cardano ha iniziato a scendere quando la Securities and Exchange Commission (SEC) degli Stati Uniti ha citato in giudizio gli scambi di Binance e Coinbase per offrire servizi di titoli non registrati. Secondo la SEC, Cardano è un titolo non registrato.</p>
<h3 id="h3-Cardano20continuer20a20scendere163228"><a name="Cardano continuerà a scendere?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cardano continuerà a scendere?</h3><p>È improbabile che il prezzo di Cardano continui a diminuire. Già ora, il mercato mostra un recupero dalla recente caduta del prezzo ADA. Attualmente, il suo prezzo oscilla tra $0.26 e $0.28.</p>
<h3 id="h3-Cardano20risorger20di20nuovo93063"><a name="Cardano risorgerà di nuovo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cardano risorgerà di nuovo?</h3><p>Il valore di Cardano è probabile che aumenti nuovamente una volta che il mercato si adatti alla posizione regolamentare della SEC sulla moneta. Già, il suo valore si sta muovendo lateralmente anziché cadere. Questo è un segno di consolidamento dopo il quale il suo prezzo potrebbe iniziare a salire.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>