VGVuZGVuemEgZGkgbWVyY2F0b++9nElsIHNlcnZpemlvIGRpIHN0YWtpbmcgRVRIIGRpIFJvY2tldCBQb29sIHJhZ2dpdW5nZSAxIG1pbGlhcmRvIGRpIGRvbGxhcmkgZGkgVFZMOyBsYSBSdXNzaWEgb2ZmcmUgc292dmVuemlvbmkgcGVyIGlsIG1pbmluZyBkaSBjcmlwdG92YWx1dGUgaW4gU2liZXJpYQ==

2023-02-10, 03:20

<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>Nell’ultima settimana, il mercato delle criptovalute è stato testimone di un declino progressivo, con la capitalizzazione di mercato totale che è scesa a 1,2 miliardi di dollari, una diminuzione di 600 milioni di dollari rispetto alla settimana precedente. Con il momentum rialzista visto dall’inizio del 2023 che sembra affievolirsi, sembra che una correzione rialzista abbia ostacolato il mercato, causando perdite fino al 10% nelle prime 20 t <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">criptovaluta</a> valute. Tuttavia, ci sono state notizie rialziste per suscitare un potenziale sentimento positivo tra gli investitori questa settimana, con <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a> Il TVL di Gate.io ha raggiunto 1 miliardo di dollari sul loro <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il servizio di staking mentre l’upgrade di Shanghai si prepara per la distribuzione. Inoltre, le autorità russe hanno offerto alle società controllate della criptovaluta in Siberia di creare una nuova struttura mineraria di proprietà statale. D’altra parte, la borsa di criptovalute Kraken ha annunciato di essere pronta a chiudere il suo servizio di staking criptovalutario negli Stati Uniti poiché si apprestano a pagare una multa di 30 milioni di dollari in un accordo con la SEC.</p>
<h2 id="h2-Le20ultime20notizie908648"><a name="Le ultime notizie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le ultime notizie</h2><h3 id="h3-Rocket20Pool2020Il20servizio20di20staking20ETH20di20Gateio20raggiunge20i20320miliardi20in20TVL358992"><a name="Rocket Pool  Il servizio di staking ETH di Gate.io raggiunge i $3 miliardi in TVL" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a> Il servizio di staking ETH di Gate.io raggiunge i $3 miliardi in TVL</h3><p>Il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> servizio di staking, <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a> è stato confermato di aver raggiunto 1 miliardo di dollari di valore totale bloccato (TVL) ieri secondo un rapporto dati rilasciato da DefiLlama. Avendo raggiunto questo traguardo storico in meno di due anni dal lancio della mainnet nel novembre 2021, <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a> è accelerato in popolarità offrendo agli utenti l’accesso a un <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> strumento per operatori di nodi decentralizzati che consente loro di eseguire il proprio nodo.</p>
<p>Riducendo il requisito di ingresso per <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> staking e operationalizzazione del nodo attraverso la riduzione dei requisiti di capitale e tecnici, <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a> consente <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli staker possono entrare nella pool con soli 0,01 ETH, rispetto ai tradizionali 32 ETH necessari per gestire un nodo. A sua volta, questo si è democratizzato <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> accesso allo staking e ha fornito un modo più accessibile e decentralizzato per raccogliere le ricompense dello staking.<br><img src="https://gimg2.gateimg.com/image/article/16759990831.png" alt=""><a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a> Logo (Immagine cortesia di <a href="/price/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">Rocket Pool</a>)</p>
<h3 id="h3-Kraken20chiude20il20programma20di20staking20negli20Stati20Uniti20in20seguito20a20un20accordo20di203020milioni20con20la20SEC668479"><a name="Kraken chiude il programma di staking negli Stati Uniti in seguito a un accordo di $30 milioni con la SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kraken chiude il programma di staking negli Stati Uniti in seguito a un accordo di $30 milioni con la SEC</h3><p>La piattaforma internazionale di scambio di asset digitali, Kraken, ha annunciato che ‘immediatamente’ interromperà tutte le offerte di staking-as-a-service per i clienti statunitensi e pagherà una multa di 30 milioni di dollari per risolvere una causa con la SEC, l’agenzia che ha accusato Kraken di offrire titoli non registrati. Cessando le operazioni di staking che sono state in atto dal 2019, Kraken staccherà automaticamente tutti gli asset staccati dai clienti statunitensi, ad eccezione dei token ETH, che saranno staccati dopo l’aggiornamento di Shanghai.</p>
<p>Secondo un comunicato dell’ SEC, il loro reclamo sostiene che ‘Kraken si vanta del fatto che il suo programma di investimento nel proof-of-stake offre una piattaforma facile da usare e vantaggi che derivano dagli sforzi di Kraken a favore degli investitori, tra cui le strategie di Kraken per ottenere rendimenti e pagamenti regolari degli investimenti.’. Questo avviene alla luce del comunicato stampa della SEC che suggerisce che i tassi di rendimento di Kraken possano essere fino al 21% quando l’exchange aveva inizialmente citato il 20%.<br><img src="https://gimg2.gateimg.com/image/article/16759991042.png" alt=""><br>Logo di Kraken (Immagine Cortesia di Kraken)</p>
<h3 id="h3-La20Russia20offre20sovvenzioni20sullestrazione20di20criptovalute20in20Siberia851703"><a name="La Russia offre sovvenzioni sull’estrazione di criptovalute in Siberia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Russia offre sovvenzioni sull’estrazione di criptovalute in Siberia</h3><p>L’agenzia media russa RBC ha rilasciato un rapporto l’8 febbraio affermando che la società di stato per lo sviluppo dell’Estremo Oriente ha annunciato l’istituzione di un centro di mining di criptovalute in Buryatia, una repubblica nella Siberia orientale. Di conseguenza, verrà costruita una nuova struttura di mining, contenente 30.000 macchine da mining, impiegherà 100 persone e preleverà 100 megawatt dalla rete elettrica principale. È previsto che aprirà nella prima metà del 2023 e sarà di proprietà di Trover, il più grande fornitore russo di servizi di colocation per il mining di criptovalute.</p>
<p>Ciò si verifica alla luce dell’offerta della Russia di sussidi per il mining di criptovalute in Siberia, il che consentirà al centro di mining di beneficiare di una serie di incentivi. Questi includeranno l’esenzione dalle tasse fondiarie e immobiliari, i costi dell’elettricità dimezzati, così come un’aliquota fiscale sul reddito più bassa.<br><img src="https://gimg2.gateimg.com/image/article/16759991243.png" alt=""><br>Crypto Mining (Immagine cortesia di Spectrum IEEE)</p>
<h2 id="h2-Tendenze20attuali20dei20progetti763142"><a name="Tendenze attuali dei progetti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze attuali dei progetti</h2><p>In base ai dati forniti da CoinMarketCap, la maggior parte dei progetti che hanno guadagnato maggiormente nella scorsa settimana si sono concentrati sia su Binance Smart Chain che su NFT. Uno dei progetti che ha guadagnato maggiormente e si è concentrato sulla coppia è DINGO TOKEN, che ha registrato una crescita senza precedenti del 6318,46% nelle ultime 24 ore. Questo dimostra che gli NFT sono di nuovo in cima alle preferenze e hanno destato l’interesse degli investitori in una gamma di blockchain.</p>
<h2 id="h2-La20tendenza20attuale20del20BTC93766"><a name="La tendenza attuale del BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La tendenza attuale del BTC</h2><p>Dopo essere sceso del 7,11% negli ultimi sette giorni, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha iniziato un progressivo declino nell’ultima settimana a seguito della precedente realizzazione di una formazione rialzista a croce d’oro nelle settimane precedenti. Essendo entrato nella settimana a un s <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> g $23.54k, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha brevemente superato la sua SMA a 7 giorni prima di iniziare una rapida discesa il 4, che alla fine ha aperto la strada a BTC per superare i $23k il 5 e iniziare a scendere attraverso la regione di $22k - senza segni di fermarsi.</p>
<p>La traiettoria attuale del prezzo di BTC sembra indicare una correzione del prezzo alla luce del recente slancio rialzista, che si verifica in concomitanza con il miglioramento graduale dei mercati internazionali in quanto l’inflazione sembra diminuire in tutto il mondo e le situazioni geopolitiche iniziano a calmarsi. È probabile che nelle prossime settimane… <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> potrebbe continuare a seguire questa traiettoria, tuttavia, è fondamentale notare che il BTC sta ancora negoziando costantemente al di sopra della sua SMA a 1 mese, il che potrebbe essere indicativo di una correzione minore in una traiettoria di prezzo rialzista di un mese.</p>
<p>Alla luce di questo crescente sentiment bearish, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il MVRV (market value to realized value) di ‘s ha iniziato a stagnare e diminuire, ma è rimasto costantemente al di sopra della soglia di 1. Iniziando la settimana con un massimo di 1,183, il MVRV di BTC è stato uno dei valori più alti degli ultimi settimane prima di scendere a un minimo settimanale di 1,144 il 9. Questo segnala che BTC continua a rimanere al di sopra dell’indicazione di ‘fondo di mercato’, il che significa che sta mantenendo la sua posizione sopra i $20,000.<br><img src="https://gimg2.gateimg.com/image/article/16759992114.png" alt=""><br>Dati settimanali BTC MVRV (dati per gentile concessione di Blockchain.com)</p>
<h2 id="h2-Lo20stato20delle20commissioni20gas20di20ETH448439"><a name="Lo stato delle commissioni gas di ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo stato delle commissioni gas di ETH</h2><p>A partire dal 9 febbraio, c’è stata una moderata diminuzione del volume totale di gas utilizzato nell’ultima settimana rispetto alla prima, con la cifra più bassa raggiunta l’8, per un totale di 107.868.173.706. La cifra più alta raggiunta questa settimana è stata il 6, per un totale di 108.517.726.041, dimostrando un utilizzo totale simile a quello visto durante l’apertura del 2023. Questo calo nella regione 107B è indicativo di una tendenza al graduale calo dell’utilizzo di gas nell’ultimo mese.</p>
<p>Di conseguenza, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> I limiti delle commissioni gas questa settimana hanno avuto una notevole diminuzione rispetto alla settimana precedente. I limiti bassi delle commissioni gas erano compresi tra 12-165 gwei, i limiti medi erano compresi tra 13-165 gwei e i limiti alti erano compresi tra 13-305 gwei - dimostrando una vasta disparità nelle commissioni gas nell’ultima settimana.</p>
<p>Nelle ultime 24 ore, i principali ‘Gas Guzzlers’ secondo Etherscan sono stati <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>: Universal Router (con commissioni totali di $ 598.050,78 o 387,23 ETH), Seaport 1.1 (con commissioni totali di $ 474.431,43 o 307,18 ETH) e <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Cavezza</a>: USDT Stabl <a href="/price/ecoin-ecoin" rel="nofollow noopener noreferrer" target="_blank">Ecoin</a> (con commissioni per un totale di $302,029.00 o 195.56 ETH) - dimostrando così un aumento significativo rispetto alla settimana precedente.</p>
<p>Il costo stimato delle transazioni tra i simili di OpenSea: Vendita, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> V3: Swap e USDT: Transfer sono stati suggeriti di essere tra $3,76 e $13,39, secondo Etherscan.</p>
<h2 id="h2-Lattuale20situazione20macro290010"><a name="L’attuale situazione macro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’attuale situazione macro</h2><h3 id="h3-Gli20esperti20di20Munich20Re20ritengono20che20leconomia20globale20del20202320sar20plasmata20dallinflazione242533"><a name="Gli esperti di Munich Re ritengono che l’economia globale del 2023 sarà plasmata dall’inflazione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli esperti di Munich Re ritengono che l’economia globale del 2023 sarà plasmata dall’inflazione</h3><p>Le previsioni economiche del 2023 di Munich Re hanno previsto che l’alta inflazione e la bassa crescita economica dipingeranno il quadro dell’economia globale nel 2023. Tuttavia, è previsto che l’economia internazionale farà meglio di quanto precedentemente previsto con le tensioni geopolitiche, forti aumenti dei prezzi e tassi di interesse più elevati.</p>
<p>Il capo economista Michael Menhart ha commentato: ‘L’economia globale è diversa da quella del periodo pre-Covid e pre-bellico, e probabilmente rimarrà tale per un bel po’. Con l’inflazione, i tassi di interesse più alti, le interferenze governative e i rischi geopolitici che plasmano le prospettive. Sul lato positivo, possiamo ora dire che le previsioni non sembrano così cupe come molti si aspettavano mezzo anno fa’.</p>
<h2 id="h2-Cosa20potrebbe20arrivare20nella20settimana20a20venire930429"><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 è entrato in una traiettoria apparentemente più ribassista, è probabile che il mercato continuerà a scendere progressivamente nei prossimi giorni. Tuttavia, con l’emergere di notizie più rialziste, questa positività potrebbe tradursi in un sentimento più rialzista tra gli investitori di tutto il mercato. Pertanto, a sua volta, la ripresa del mercato potrebbe dipendere dal sentiment generale all’interno della comunità più ampia.</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 venga citato Gate.io. In tutti gli altri casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>