VGVuZGVuemEgZGkgbWVyY2F0byB8IElsIG1pbmVyIGRpIEJpdGNvaW4gUmlvdCBzZWduYWxhIHVuIGF1bWVudG8gZGVsbGEgcHJvZHV6aW9uZSwgbGEgYmFuY2EgcnVzc2EgZW1ldHRlIHVuYSBnYXJhbnppYSBiYW5jYXJpYSBvbi1jaGFpbiBpbiB5dWFuIGNpbmVzZQ==

2023-03-03, 03:37

<p><img src="https://gimg2.gateimg.com/image/article/1666334998%E4%B8%80%E5%91%A8%E8%A1%8C%E6%83%85.jpeg" alt=""><br>Nel corso dell’ultima settimana, il mercato delle criptovalute ha iniziato principalmente a diminuire, con candele rosse onnipresenti nel corso della settimana scorsa. Ciò ha portato a perdite fino al 15% tra le prime 100, con poche che deviano da questo trend negativo.</p>
<p>In linea con questo sentiment negativo, i membri della camera dei rappresentanti del Dakota del Sud stanno cercando di modificare l’UCC per vietare l’uso delle criptovalute, ma ciò non si estende ai casi d’uso delle CBDC, suscitando così indignazione tra le comunità crypto. Divergendo da questo sentiment negativo, il miner di BTC Riot Platforms, Inc. ha riportato un notevole aumento della produzione e il triplicarsi del loro hash rate nel corso del 2022. Allo stesso modo, una delle più grandi banche della Russia, la Moscow Credit Bank, ha emesso una garanzia bancaria basata su blockchain denominata in yuan cinese, che viene presentata come la prima nel paese.</p>
<h2 id="h2-Le20ultime20notizie968337"><a name="Le ultime notizie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le ultime notizie</h2><h3 id="h3-Bitcoin2020Report20sui20disordini20dei20minatori20laumento20dei20risultati648292"><a name="Bitcoin  Report sui disordini dei minatori, l’aumento dei risultati" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Report sui disordini dei minatori, l’aumento dei risultati</h3><p>Il <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La potenza mineraria, Riot Platforms, Inc., ha riportato un fatturato di $259,2 milioni per il 2022, attribuito all’aumento della produzione. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> produzione e un intero anno di entrate per l’hosting e l’ingegneria. Il minatore ha prodotto un totale di 5.554 BTC, in aumento del 46% rispetto all’anno precedente, che Riot ha dichiarato essere il risultato della loro ‘forza finanziaria leader nel settore’ che la mette in una posizione forte per continuare ad eseguire i suoi ‘piani di crescita aggressivi’. Inoltre, Riot ha anche riferito di aver triplicato la capacità del proprio tasso di hash.</p>
<p>D’altra parte, le entrate minerarie di Riot sono diminuite, eppure il CEO di Riot, Jason Les, ha citato la diminuzione della valutazione del BTC come motivo di questo calo. Tuttavia, a causa di un cambiamento contabile relativo al modo in cui il BTC è rappresentato nei bilanci, Riot ha riportato in una comunicazione alla SEC che i suoi precedenti bilanci finanziari del 2020 e del 2021 ‘non dovrebbero più essere considerati affidabili’, ma questo verrà emendato in una comunicazione 10-K per il 2022.<br><img src="https://gimg2.gateimg.com/image/article/16778144101.png" alt=""><br>Costruzione F, un edificio per l’estrazione di BTC nell’impianto di Riot (Immagine cortesia di Bloomberg)</p>
<h3 id="h3-Il20progetto20di20emendamento20UCC20proposto20dal20Sud20Dakotan20vieta20le20criptovalute328175"><a name="Il progetto di emendamento UCC proposto dal Sud Dakotan vieta le criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il progetto di emendamento UCC proposto dal Sud Dakotan vieta le criptovalute</h3><p>Il repubblicano del Dakota del Sud, Mike Stevens, ha recentemente presentato un emendamento di 117 pagine alla Camera dei Rappresentanti che cerca di modificare il Codice Commerciale Uniforme (UCC) per limitare la definizione di denaro escludendo le criptovalute. Tuttavia, le CBDC saranno ancora definite come ‘denaro’ in base a questa legislazione, agendo come una sorta di eccezione a questa proposta. Stevens ha definito il denaro come un ‘mezzo di scambio attualmente autorizzato o adottato da un governo nazionale o straniero’, ma ha precisato che il ‘termine non include un registro elettronico’, in particolare uno che operava prima dell’autorizzazione e l’adozione del governo.</p>
<p>Questa proposta di legge contrasta nettamente con la recente ‘Legge Anti-Sorveglianza dello Stato CBDC’ presentata alla Camera dei Rappresentanti dal repubblicano del Minnesota Tom Emmer, spesso considerato un sostenitore delle criptovalute. A seguito della proposta di Steven, molti politici e figure di spicco nel settore delle criptovalute si sono rivolti a internet per esprimere il loro disgusto per il fatto che il governo degli Stati Uniti si stia avvicinando alle CBDC e stia respingendo le criptovalute più ampie.<br><img src="https://gimg2.gateimg.com/image/article/16778144452.png" alt=""><br>Arte illustrativa Anti-Crypto (Immagine cortesia di Asia Blockchain Review)</p>
<h3 id="h3-La20banca20russa20emette20una20garanzia20bancaria20onchain20in20yuan20cinese512459"><a name="La banca russa emette una garanzia bancaria on-chain in yuan cinese" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La banca russa emette una garanzia bancaria on-chain in yuan cinese</h3><p>All’inizio di questa settimana, la Moscow Credit Bank ha emesso una garanzia bancaria basata su blockchain denominata in yuan cinese. La garanzia bancaria supera i 100 milioni di yuan cinesi (o $114.600 al momento della scrittura). La transazione è stata effettuata attraverso la piattaforma blockchain Masterchain, la rete blockchain nazionale russa che facilita i trasferimenti digitali nazionali. Si prevede che questa garanzia bancaria agisca come salvaguardia finanziaria in caso di operazioni di prestito, eppure se un pagamento viene effettuato in base alla garanzia, il beneficiario riceverà rubli russi al tasso di cambio concordato dalle parti organizzatrici, nonostante la garanzia sia collegata al yuan.</p>
<p>Questo iniziativa di adozione di criptovalute transfrontaliera avviene alla luce della banca centrale della Russia che si prepara a lanciare il primo test pilota per il suo CBDC il 1° aprile di quest’anno. Si prevede che il rublo digitale sarà facilitato da 13 banche locali e diversi commercianti in tutto il paese.<br><img src="https://gimg2.gateimg.com/image/article/16778144803.png" alt=""><br>Logo di Masterchain (Immagine cortesia di TAdviser)</p>
<h2 id="h2-Tendenze20attuali20del20progetto568150"><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 di maggior successo della settimana scorsa si è concentrato sull’integrazione di scenari applicativi in vari aspetti e da molteplici prospettive, al fine di cercare modi in cui la tecnologia blockchain possa affrontare e risolvere problemi in una moltitudine di reti, con queste reti che non hanno la capacità di risolverli. Questo asset si chiama Orient Walt, ed è aumentato di un incredibile 113,28% in un solo giorno, portandolo a raggiungere $0,017.</p>
<h2 id="h2-La20tendenza20attuale20di20BTC207333"><a name="La tendenza attuale di BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La tendenza attuale di BTC</h2><p><img src="https://gimg2.gateimg.com/image/article/16778145334.png" alt=""><br>Settimanalmente <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 scorsa, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è stato soggetto a un’enorme volatilità che l’ha spinto al di sotto della sua SMA a 7 giorni e lo ha fatto precipitare dalla regione di $24k a un minimo settimanale di $22.898,30. Fortunatamente, BTC ha iniziato a riprendere piede sopra questa regione e a spostarsi ulteriormente verso i $23,5k, portandolo a scambiarsi a una media di $23,49k durante la settimana, con BTC che ha chiuso su questo valore il 2°.</p>
<p>La traiettoria attuale del prezzo del BTC sembra indicare che stia iniziando a allontanarsi ulteriormente dalla zona di resistenza di $25k e potenzialmente a stabilire $24k come nuova resistenza settimanale. Ciò suggerisce che <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> sta diminuendo progressivamente e potenzialmente correggendosi, portandolo a scambiarsi tra $22.8k e $23.5k.</p>
<p>Alla luce di questo, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il MVRV (valore di mercato rispetto al valore effettivo) di Gate.io è entrato nella settimana con un tasso di crescita relativamente orizzontale, segnalando un breve periodo di stasi. Tuttavia, alla fine di febbraio, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’MVRV di ‘s ha iniziato a salire bruscamente, passando da una media di 1,175 a un massimo settimanale di 1,18. Tuttavia, si tratta di una diminuzione notevole rispetto alla settimana precedente, in cui l’MVRV di BTC ha esplorato il territorio di 1,2, suggerendo che <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il valore sta iniziando a avvicinarsi nuovamente alla zona di ipovenduto e sottovalutata.<br><img src="https://gimg2.gateimg.com/image/article/16778145555.png" alt=""><br>Dati MVRV BTC a 5 giorni (Dati cortesia di Blockchain.com)</p>
<h2 id="h2-La20situazione20dello20staking20di20ETH568667"><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 2 marzo, la situazione di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il posizionamento rimane relativamente positivo, soprattutto considerando l’imminente <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Shanghai upgrade, che concederà a tutti i validatori che hanno scommesso <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> sbloccare progressivamente i loro token e il rendimento successivo guadagnato. Inoltre, il volume di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il deposito alla Beacon Chain è continuato a crescere a un tasso relativamente elevato dall’inizio del 2023, con ciò che si estende fino ai primi di marzo.<br><img src="https://gimg2.gateimg.com/image/article/16778145766.png" alt=""><br>(Dati forniti da Dune)</p>
<p>Ecco alcuni dati chiave della settimana appena trascorsa per consolidare tutto ciò:</p>
<p>Totale validatori: 512,657<br>Indirizzi dei depositanti: 90,200<br>Totale ETH depositato: 16,353,927<br>Percentuale di staking liquido: 35.38%<br>Quote staccate dell’offerta di ETH: 14.49%</p>
<p>Oltre a quanto sopra, l’interesse più ampio del mercato delle criptovalute e delle finanze verso i derivati liquidi è aumentato, portando il token di governance LDO (il token nativo del DAO dietro il fornitore di staking liquido Lido) a salire del 33% e il suo concorrente, RPL, (il token nativo di <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a>) aumentare del 18%. Questo è probabilmente dovuto al loro ruolo critico nel ridurre le barriere di accessibilità per gli individui che intendono scommettere le loro <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, consentendo agli utenti di depositare qualsiasi importo di Ether, assegnandolo a un validatore specifico fino a quando non viene raggiunto l’importo richiesto di Ether.</p>
<h2 id="h2-La20situazione20macro20attuale277383"><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-Gli20Emirati20Arabi20Uniti20sono20stati20identificati20come20un20paese20di20focus20mentre20gli20Stati20Uniti20si20muovono20per20prendere20di20mira20i20partner20economici20russi693420"><a name="Gli Emirati Arabi Uniti sono stati identificati come un ‘paese di focus’ mentre gli Stati Uniti si muovono per prendere di mira i partner economici russi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli Emirati Arabi Uniti sono stati identificati come un ‘paese di focus’ mentre gli Stati Uniti si muovono per prendere di mira i partner economici russi</h3><p>Nelle ultime 24 ore, è diventato di dominio pubblico che gli Stati Uniti hanno iniziato a guardare verso gli Emirati Arabi Uniti come ‘paese di focus’ mentre si muove per sopprimere i legami della Russia con l’economia globale. Elizabeth Rosenberg, segretario assistente al Tesoro per il finanziamento del terrorismo e i reati finanziari, ha dichiarato: ‘Siamo particolarmente preoccupati per l’aumento del commercio con la Russia per quanto riguarda il tipo di beni che possono essere utilizzati in campo di battaglia e coloro che stanno aiutando le entità russe designate’. Questi commenti giungono alla luce delle crescenti preoccupazioni in Occidente che gli Emirati Arabi Uniti, insieme a paesi come la Turchia, stiano agendo come linea vitale economica critica della Russia mentre il conflitto Russia-Ucraina continua.</p>
<p>È stato riferito che gli Emirati Arabi Uniti hanno esportato beni, incluso beni controllati per l’esportazione negli Stati Uniti come ‘dispositivi a semiconduttore’, che rappresentano il 30% del valore totale di tutte le loro esportazioni, che l’Occidente ritiene possano essere utilizzati sul campo di battaglia. Di conseguenza, si dice che Washington sia diventata ‘sempre più frustrata’ con il modello di business degli Emirati Arabi Uniti e stia cercando di intensificare ulteriormente la repressione sulla nazione.</p>
<h2 id="h2-Cosa20potrebbe20arrivare20nella20settimana20a20venire435340"><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>Con il mercato che ha un sentimento negativo questa settimana, è probabile che ciò si verifichi anche nella prossima settimana, tuttavia, la traiettoria di valutazione sottostante per la maggior parte degli asset nei primi 100 sembra essere indicativa di un aumento progressivo e graduale su scala trimestrale, il che allude ad una valutazione di mercato progressivamente crescente su scala a lungo termine.</p>
<div class="blog-details-info"><br><div>Autore: Ricercatore di 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. Sarà consentito il ripostaggio dell'articolo 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>