VGVuZGVuemEgZGkgbWVyY2F0b++9nElsIFRlc29ybyBzdGF0dW5pdGVuc2UgcHJvcG9uZSB1bmEgdGFzc2EgZGVsIDMwJSBzdWkgbWluYXRvcmkgZGkgY3JpcHRvdmFsdXRlLCBTaWx2ZXJnYXRlIGNvbGxhc3NhIG5lbCBiZWwgbWV6em8gZGVsbCdhdmFuemFyZSBkZWxsJ2ludmVybm8gY3JpcHRv

2023-03-10, 03:35

<p><img src="https://gimg2.gateimg.com/image/article/167843662920230310-162305.jpeg" alt=""></p>
<p>Nella settimana appena trascorsa, il mercato delle criptovalute è stato colpito nuovamente dall’inverno delle criptovalute, con candele rosse che sono emerse nella maggior parte delle prime 100 - con molto poche che hanno avuto una qualche protezione da questa tendenza ribassista. Di conseguenza, perdite fino al 22% sono state comuni questa settimana, con personaggi come <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e <a href="/price/litecoin-ltc" rel="nofollow noopener noreferrer" target="_blank">Litecoin</a> shedding poco più del 20% rispettivamente nella scorsa settimana. In linea con questo sentiment ribassista, il Tesoro degli Stati Uniti ha proposto una nuova tassa di accisa del 30% sulle aziende di mining di criptovalute. Allo stesso modo, <a href="/price/kucoin-kcs" rel="nofollow noopener noreferrer" target="_blank">KuCoin</a> è stato criticato nella scorsa settimana, con il Procuratore Generale di New York che ha citato in giudizio l’azienda per la presunta vendita di titoli e materie prime - con ETH che ora viene considerato un titolo in tribunale. A seguito di questa nota ribassista, il gigante delle banche crittografiche, Silvergate, si è liquidato mentre il panorama di mercato continua a oscurarsi.</p>
<h2 id="h2-Ultime20notizie390381"><a name="Ultime notizie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultime notizie</h2><h3 id="h3-Il20Tesoro20degli20Stati20Uniti20propone20unimposta20del203020sui20minatori20di20criptovalute753552"><a name="Il Tesoro degli Stati Uniti propone un’imposta del 30% sui minatori di criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il Tesoro degli Stati Uniti propone un’imposta del 30% sui minatori di criptovalute</h3><p>Con il presidente degli Stati Uniti, Joe Biden, che ha svelato la sua proposta di bilancio per il 2023 giovedì, il Dipartimento del Tesoro degli Stati Uniti ha proposto una tassa di accisa del 30% sul costo dell’elettricità utilizzata per alimentare le strutture di mining di criptovalute. In una disposizione del ‘Greenbook’ del dipartimento, è stata proposta una tassa basata sui costi dell’elettricità utilizzata nei processi di mining o definita come ‘utilizzo di risorse informatiche’ per estrarre qualsiasi criptovaluta.</p>
<p>Di conseguenza, le aziende di mining di criptovalute negli Stati Uniti potrebbero essere tenute a segnalare il loro consumo di elettricità e il tipo di energia utilizzata. Inoltre, questa tassa verrà gradualmente introdotta nei prossimi tre anni, con un aumento del dieci per cento annuo. Questa tassazione è destinata a potenzialmente ‘ridurre il numero complessivo di macchine da mining negli Stati Uniti’ a causa delle crescenti preoccupazioni ambientali.<br><img src="https://gimg2.gateimg.com/image/article/16784191981.png" alt=""><br>Una Riot (una nota azienda statunitense di mining di criptovalute) Branch (Immagine cortesia di Bloomberg)</p>
<h3 id="h3-KuCoin2020Citato20in20giudizio20mentre20gli20avvocati20sostengono20che20ETH20sia20un20titolo66478"><a name="KuCoin  Citato in giudizio mentre gli avvocati sostengono che ETH sia un titolo" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/kucoin-kcs" rel="nofollow noopener noreferrer" target="_blank">KuCoin</a> Citato in giudizio mentre gli avvocati sostengono che ETH sia un titolo</h3><p>Il procuratore generale dello stato di New York, Letitia James, ha rivelato di aver intentato una causa contro il gigante dello scambio di criptovalute, <a href="/price/kucoin-kcs" rel="nofollow noopener noreferrer" target="_blank">KuCoin</a>, dopo essere riuscita a effettuare transazioni di criptovalute tramite lo scambio. Anche se questo potrebbe sembrare un’attività consueta da parte dello scambio, a causa delle criptovalute non essere registrate a New York, questo ha fatto suonare i campanelli d’allarme per James. Deposita il 9 marzo presso la Corte Suprema dello Stato di New York County, la denuncia afferma che <a href="/price/kucoin-kcs" rel="nofollow noopener noreferrer" target="_blank">KuCoin</a> ha violato le leggi statali sui titoli, osservando che ciò è avvenuto quando hanno facilitato la transazione di criptovalute che sono ‘beni e titoli’.</p>
<p>Di conseguenza, il suo ufficio ha dichiarato che ‘questa azione è una delle prime volte in cui un regolatore afferma in tribunale che ETH, una delle più grandi criptovalute disponibili, è una security’. Tuttavia, le affermazioni di James che ETH è una security emergono alla luce delle dichiarazioni delle autorità federali e statali secondo cui ETH, insieme a LUNA e UST, sono materie prime.</p>
<h3 id="h3-Silvergate20collassa20in20mezzo20allavanzare20dellinverno20cripto468697"><a name="Silvergate collassa in mezzo all’avanzare dell’inverno cripto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Silvergate collassa in mezzo all’avanzare dell’inverno cripto</h3><p>Unendosi alla moltitudine di aziende cripto in crisi, Silvergate Bank, un enorme conglomerato di prestiti cripto noto per aver prestato all’infame FTX, ha annunciato la sua imminente liquidazione a causa di preoccupazioni interne sulla longevità del mercato cripto. Avendo stabilito una reputazione come la banca cripto di riferimento negli Stati Uniti, con un totale di $14 miliardi di depositi dei clienti, il crollo di Silvergate riflette il più ampio mercato cripto ribassista alla luce del crollo di FTX.</p>
<p>Il crollo di FTX ha comportato una riduzione dannosa dei depositi dei clienti di Silvergate e del prezzo delle azioni, che si è trasformato nella liquidazione dell’azienda.</p>
<h2 id="h2-Tendenze20attuali20del20progetto439364"><a name="Tendenze attuali del progetto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze attuali del progetto</h2><p>Sulla base dei dati forniti da CoinMarketCap, il progetto che ha registrato il maggior aumento nella scorsa settimana si è focalizzato sulla creazione di una piattaforma e un servizio completamente integrati e user-friendly che si sforzano di connettere il maggior numero possibile di principianti nel settore delle blockchain con una serie di prodotti leader nel mercato di DeFi, GameFi e P2E. Questo asset si chiama Supreme Finance e è aumentato in modo impressionante del 179,98% in un solo giorno, raggiungendo così $0.002072.</p>
<h2 id="h2-Il20trend20attuale20del20BTC824873"><a name="Il trend attuale del BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il trend attuale del BTC</h2><p><img src="https://gimg2.gateimg.com/image/article/16784192602.png" alt=""><br>Settimanale <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo btc</a> Dati (Dati Cortesia di Blockchain.com)</p>
<p>Durante la settimana appena trascorsa, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è rimasto in una traiettoria di trading orizzontale per la maggior parte della settimana. Negociando a una media di $22,33k, BTC è rimasto relativamente costantemente al di sopra della sua SMA a 7 giorni fino all’8, quando ha iniziato a declinare progressivamente al di sotto di questa soglia e a oscillare sopra i $22k. Tuttavia, il 9 ha portato la traiettoria a svelarsi in una forte diminuzione, che ha portato BTC a un minimo di diversi mesi di $20,1k.</p>
<p>Tuttavia, nonostante questa rapida degradazione del prezzo, gli analisti stanno ipotizzando che l’aumento del sentimento negativo possa precludere un rimbalzo a breve termine nella valutazione. A causa dell’afflusso di ‘FUD’ di mercato, la società di analisi, Santiment, ha suggerito che ciò aumenta le ‘probabilità’ di ribalzi dei prezzi contrarian. Tuttavia, l’indice della paura e della cupidigia è sceso ai minimi di due mesi, a 44, ma rimane saldamente al di sopra dei livelli storici di rimbalzo tra 10 e 25, il che significa che qualsiasi rimbalzo dei prezzi è probabile che sia effimero al meglio.</p>
<p>Alla luce di questo, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’MVRV (valore di mercato rispetto al valore realizzato) di ‘s è crollato all’inizio della settimana, prima di stagnare ed entrare in un trend discendente lento. All’inizio della settimana, l’MVRV di BTC è sceso da 1,18 a un minimo settimanale di 1,096 il 2. Di conseguenza, il valore di BTC sembra avvicinarsi nuovamente al territorio ‘sovrevenduto’.<br><img src="https://gimg2.gateimg.com/image/article/16784192844.png" alt=""><br>Dati BTC MVRV a 7 giorni (Dati cortesia di Blockchain.com)</p>
<h2 id="h2-La20situazione20dello20staking20di20ETH466982"><a name="La situazione dello staking di ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La situazione dello staking di ETH</h2><p>Al 10 marzo, lo stato di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il posizionamento rimane relativamente positivo, probabilmente a causa dell’imminente implementazione del <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Shanghai upgrade, che permetterà a tutti i validatori che hanno scommesso <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> per sbloccare progressivamente i loro token e il successivo rendimento guadagnato. Inoltre, il volume di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> depositato sulla Beacon Chain ha continuato a crescere a un ritmo relativamente ripido dall’inizio del 2023, con un forte aumento a marzo.<br><img src="https://gimg2.gateimg.com/image/article/16784193125.png" alt=""><br>(Dati cortesia di Dune)</p>
<p>Ecco alcuni dati chiave della scorsa settimana per consolidare questo:</p>
<p>Total validators: 512,657<br>Indirizzi dei depositanti: 90,200<br>Totale ETH depositati: 16,353,927<br>Percentuale di staking liquido: 35.39%<br>Quota staked dell’offerta di ETH: 14.60%</p>
<h2 id="h2-La20situazione20macro20attuale138842"><a name="La situazione macro attuale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La situazione macro attuale</h2><h3 id="h3-La20Cina20fissa20il20pi20basso20obiettivo20di20crescita20economica20degli20ultimi20tre20decenni725592"><a name="La Cina fissa il più basso obiettivo di crescita economica degli ultimi tre decenni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Cina fissa il più basso obiettivo di crescita economica degli ultimi tre decenni</h3><p>Per il secondo anno consecutivo, il premier cinese, Li Keqiang, ha annunciato che la Cina ha fissato il suo obiettivo di crescita economica annuale più basso dal 1991, con una previsione di crescita limitata a un potenziale del 5%. Di conseguenza, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> intorno al rafforzamento dell’economia ha iniziato a erodere.</p>
<p>Con previsioni simili dello scorso anno, l’economia cinese è cresciuta solo del 3%, dopo un anno di obiettivi di crescita abbandonati a causa dell’apice della pandemia di COVID-19 nel 2020. Tuttavia, con le restrizioni legate alla pandemia che si sono allentate, molti analisti hanno ipotizzato che l’obiettivo di crescita possa aumentare nel corso di quest’anno, come ha dichiarato Li durante la sessione legislativa che è ‘essenziale dare priorità alla stabilità economica’ nell’anno a venire.</p>
<h2 id="h2-Cosa20potrebbe20arrivare20nella20settimana20a20venire213975"><a name="Cosa potrebbe arrivare nella settimana a venire?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa potrebbe arrivare nella settimana a venire?</h2><p>Mentre l’inverno criptato continua a insinuare le sue unghie più in profondità e il mercato continua a sanguinare, è probabile che il mercato continui a subire l’onere di questa forza ribassista nella settimana a venire. Con la capitalizzazione di mercato ora a $ 935,84 miliardi dopo una sorprendente diminuzione del 6,15% nelle ultime 24 ore, si può affermare che la settimana a venire continuerà a ostacolare gli investitori e a alimentare un sentimento negativo che circonda il mercato.</p>
<div class="blog-details-info"><br><div>Autore: Ricercatore Gate.io: <strong>Matthew Webster-Dowsing</strong><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. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti gli altri casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>