UHJldmlzaW9uZSBzZXR0aW1hbmFsZSBkZWxsZSA1IG1vbmV0ZSB8IEJUQyBFVEggSUNQIExUQyBQRVBF

2023-05-08, 04:27

<p><img src="https://gimg2.gateimg.com/blog/1678268270797826871cs2.jpeg" alt=""></p>
<h2 id="h2-TL20DR78545"><a name="【TL; DR】" class="reference-link"></a><span class="header-link octicon octicon-link"></span>【TL; DR】</h2><p>Nella scorsa settimana, la maggior parte degli asset nelle prime cento ha registrato notevoli cali che sono variati tra il 2% e il 15%. Mentre molti hanno perso valore in modi diversi, alcuni asset si sono discostati da questa tendenza e sono stati testimoni di una crescita dei prezzi senza precedenti, tra cui il principale contendente alle criptovalute meme, PEPE. Al 8 maggio, il mercato delle criptovalute si attesta a 1,19 T$, una diminuzione di 200 milioni rispetto alla settimana precedente e una diminuzione dello 0,04% nelle ultime 24 ore.</p>
<h2 id="h2-Bitcoin20BTC128105"><a name="Bitcoin (BTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC)</h2><p>Apertura della settimana a $29.33k, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha subito un notevole calo al di sotto della sua SMA a 7 giorni, che l’ha costretto nella zona di $27,6k. Questa spirale discendente è continuata fino al 2, quando BTC ha iniziato a riprendersi e a risalire nella zona dei $28k. Questo notevole aumento è proseguito per tutta la settimana, permettendo a BTC di superare la sua SMA a 7 giorni il 6, e scambiare intorno ai $29,8k. Successivamente BTC ha iniziato a cadere progressivamente, chiudendo la settimana intorno ai $28.795.</p>
<p>Dopo aver sopportato una settimana immensamente volatile, BTC sembra essere pronto a testare potenzialmente la zona dei 30.000 dollari ancora una volta, tuttavia rimane possibile che BTC possa essere trascinato nel trend al ribasso e potrebbe potenzialmente cadere ulteriormente nella zona dei 27.000 dollari. In totale, BTC è sceso del 2,02% la scorsa settimana.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16835198571791683519776_.pic.jpg" alt=""><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Prezzo del Bitcoin</a> Dati (Dati cortesia di CoinMarketCap)</p>
<h2 id="h2-Ethereum20ETH405854"><a name="Ethereum (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ethereum (ETH)</h2><p>Dopo il calo del sentiment comunitario della scorsa settimana e le scarse performance dei prezzi, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ha iniziato a riprendersi moderatamente. Dopo essersi avviato la settimana intorno a $1.883, ETH è sceso bruscamente al di sotto della sua SMA a 7 giorni e ha trascinato lungo i limiti inferiori della zona $1.800. Tuttavia, il 2, l’ETH ha iniziato a riacquistare slancio e a spingersi progressivamente verso l’alto, portandolo a realizzare un massimo settimanale di $2.014,66 il 6. ETH è sceso da questo punto, ma ha chiuso la settimana ancora al di sopra della sua SMA a 7 giorni con una media di $1.922.</p>
<p>Avendo deviato dalla recente traiettoria di crescita negativa delineata durante la scorsa settimana, ETH sembra essere pronto per una settimana di crescita dei prezzi positiva. Avendo ora superato la zona di resistenza di $2k, sembra che ETH abbia il potenziale per continuare a approfondirsi in questa zona e liberarsi dalla sua attuale traiettoria di trading orizzontale. In totale, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è aumentato del 1,22% nella scorsa settimana.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16835198771801683519790_.pic.jpg" alt=""><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">prezzo eth</a> Dati (Dati gentilmente forniti da CoinMarketCap)</p>
<h2 id="h2-Internet20Computer20ICP912041"><a name="Internet Computer (ICP)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Internet Computer (ICP)</h2><p>Nell’ultimo trimestre, l’ICP è stato soggetto a una notevole volatilità, facendolo oscillare tra gli 8 e i 4,7 dollari, quest’ultimo ICP ha iniziato a chiudersi nell’ultima settimana. Dopo aver iniziato la settimana a $ 6,46, ICP è immediatamente sceso significativamente al di sotto della sua SMA a 7 giorni e ha attraversato rispettivamente le regioni di $ 6 e $ 5, il che lo ha portato a toccare il fondo a circa $ 5,55 il 3. ICP ha iniziato a salire moderatamente il 4, tuttavia, il 6, ICP è sceso al minimo settimanale e ha scambiato orizzontalmente a questa soglia per il resto della settimana.</p>
<p>Avendo continuato la recente traiettoria di trading ribassista, <a href="/price/internet-computer-icp" rel="nofollow noopener noreferrer" target="_blank">Internet Computer</a> sembra pronto per un’altra settimana di prestazioni dei prezzi che decimano, il che potrebbe spingerlo ulteriormente verso la zona dei $5, a condizione che il sentimento della comunità e il momentum non riescano a riprendersi. Nella settimana appena trascorsa, ICP è sceso del 13,23%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16835199031811683519802_.pic.jpg" alt=""><a href="/price/internet-computer-icp" rel="nofollow noopener noreferrer" target="_blank">prezzo icp</a> Dati (Dati forniti da CoinMarketCap)</p>
<h2 id="h2-Litecoin20LTC545851"><a name="Litecoin (LTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Litecoin (LTC)</h2><p>Dopo un trimestre di performance volatile dei prezzi, <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> ha continuato questo trend durante tutta la settimana scorsa. Entrando nella settimana a $0,88, LTC è rapidamente sceso al di sotto della sua SMA a 7 giorni durante la prima parte della settimana; tuttavia, il 4, LTC ha iniziato a riprendersi e ha brevemente superato la sua SMA a 7 giorni. Tuttavia, questo slancio è stato di breve durata, in quanto è nuovamente sceso al di sotto della soglia SMA, prima di testarla di nuovo e poi affondare di nuovo. Per tutta la restante parte della settimana, LTC è sceso sotto la zona dei $80 e è sceso a un minimo settimanale di $82,34. LTC ha iniziato a riacquistare slancio che lo ha portato a chiudere la settimana intorno agli $84.</p>
<p>Proseguendo dalla tendenza ribassista che ha colpito le prestazioni di LTC nei mesi recenti, è probabile che ciò continui anche nella prossima settimana considerando il sentimento negativo della comunità e le prestazioni del mercato più ampio. Di conseguenza, è plausibile che nelle prossime settimane LTC possa scendere nella zona superiore a 70 dollari. Nella scorsa settimana, LTC è sceso del 5,2%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16835199681821683519817_.pic.jpg" alt=""><a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">prezzo ltc</a> Dati (Dati Cortesia di CoinMarketCap)</p>
<h2 id="h2-Pepe20PEPE402855"><a name="Pepe (PEPE)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Pepe (PEPE)</h2><p>Dopo un abbondante aumento nelle ultime settimane che lo ha spinto verso l’alto di oltre il 3000%, PEPE ha continuato questa tendenza e sta ancora cercando di raggiungere nuovi massimi nella zona di scoperta dei prezzi. Entrando nella settimana a $0,0000007203, PEPE ha continuato a scambiarsi lungo una traiettoria relativamente orizzontale prima di iniziare a salire il 4. Il 6 ha permesso a PEPE di salire ulteriormente e raggiungere un massimo settimanale di circa $0,0000040. Da allora, PEPE ha iniziato a diminuire progressivamente e avvicinarsi al territorio di $0,0000025. È stato intorno a questo livello che PEPE ha chiuso la settimana.</p>
<p>Con l’attuale tendenza al rialzo volatile che è seguita, sembra che PEPE si stia spingendo verso la zona target di $0,00001 e che, a condizione che possa mantenere il suo attuale slancio di prezzo rialzista, potrebbe realizzarlo nella prossima settimana e spingersi ulteriormente nella scoperta dei prezzi. Nel corso della settimana scorsa, PEPE è aumentato del 320,62%.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16835199891831683519837_.pic.jpg" alt=""><br>Dati sui prezzi di PEPE (Dati forniti da CoinMarketCap)</p>
<div class="blog-details-info"><br><div>Autore:<strong>Matthew Webster-Dowsing</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 il ripostaggio dell'articolo a condizione che venga indicato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>