VGVuZGVuemEgZGkgbWVyY2F0b++9nEVsIFNhbHZhZG9yIGJhbmRpc2NlIGwnaW1wb3N0YSBzdWxsJ2lubm92YXppb25lIHRlY25vbG9naWNhLCBGVFggb3R0aWVuZSBsJ2FwcHJvdmF6aW9uZSBwZXIgdmVuZGVyZSBMZWRnZXJYIHBlciAkNTAgbWlsaW9uaQ==

2023-05-05, 03:47

<p><img src="https://gimg2.gateimg.com/image/article/167843662920230310-162305.jpeg" alt=""><br>Nella scorsa settimana, il mercato delle criptovalute ha subito alti e bassi con perdite e guadagni minori tra le prime 100. Con questa quantità minima di movimento, il lato delle notizie delle criptovalute è stato riempito fino all’orlo di notizie relativamente rialziste. Nella scorsa settimana, El Salvador ha annunciato una legge che elimina le tasse sulle innovazioni tecnologiche, comprese le criptovalute. Inoltre, il titolo di Coinbase è schizzato in alto a seguito di una forte crescita dei ricavi nel primo trimestre del 2023. In notizie più attuali, FTX ha ottenuto l’approvazione del tribunale fallimentare per vendere LedgerX per 50 milioni di dollari.</p>
<h2 id="h2-Ultime20notizie773094"><a name="Ultime notizie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultime notizie</h2><h3 id="h3-El20Salvador20sradica20la20tassa20sullinnovazione20tecnologica896351"><a name="El Salvador sradica la tassa sull’innovazione tecnologica" class="reference-link"></a><span class="header-link octicon octicon-link"></span>El Salvador sradica la tassa sull’innovazione tecnologica</h3><p>Il presidente salvadoregno Nayib Bukele ha recentemente firmato una legge che elimina la tassazione sulle innovazioni tecnologiche nel paese. L’Incentivo alla produzione di innovazione e tecnologia (ITMI) ha rivelato un ampio spettro di settori in cui si applica la rimozione delle tasse, che include anche la criptovaluta.</p>
<p>Questa iniziativa è volta a incoraggiare i minatori di criptovalute e le aziende di criptovalute a trasferire la loro base operativa nel paese poiché questa nuova legge promuoverà l’innovazione e la crescita senza i livelli elevati di tassazione riscontrati in nazioni come gli USA.<br><img src="https://gimg2.gateimg.com/image/article/16832583221.png" alt=""><br>Arte illustrativa (Immagine cortesia di Getty Images)</p>
<h3 id="h3-Il20titolo20di20Coinbase20vola20dopo20la20crescita20dei20ricavi500372"><a name="Il titolo di Coinbase vola dopo la crescita dei ricavi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il titolo di Coinbase vola dopo la crescita dei ricavi</h3><p>Giovedì scorso, Coinbase ha pubblicato la lettera ai soci del primo trimestre del 2023, che ha sottolineato il suo impegno a rivitalizzare i sistemi finanziari obsoleti attuali e ad ampliare l’accesso alle criptovalute, delineando la loro aspirazione di coinvolgere un miliardo di persone nell’ecosistema delle criptovalute. Il rapporto segnava un punto di svolta per Coinbase poiché dimostrava il loro impegno nel tagliare i costi, migliorare l’eccellenza operativa, la gestione del rischio, migliorare l’innovazione del prodotto e la chiarezza regolamentare.</p>
<p>Di conseguenza, Coinbase ha riportato una crescita del 22% trimestre su trimestre del fatturato netto, una diminuzione del 24% T/T delle spese operative totali, una perdita netta di 79 milioni di dollari e un ritorno a un EBITDA rettificato positivo di 248 milioni di dollari. A seguito della pubblicazione della lettera, il titolo di Coinbase ha chiuso a $49,22 (+1,51) giovedì. Tuttavia, COIN è poi salito a circa $53,35 (+8,39%), superando le stime degli analisti sulla crescita del prezzo netto.</p>
<h3 id="h3-FTX20ottiene20lapprovazione20per20vendere20LedgerX20per205020milioni523175"><a name="FTX ottiene l’approvazione per vendere LedgerX per $50 milioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FTX ottiene l’approvazione per vendere LedgerX per $50 milioni</h3><p>In un recente sviluppo della procedura fallimentare FTX in corso, il tribunale fallimentare del Delaware ha autorizzato l’exchange a vendere la sua filiale LedgerX. La filiale LedgerX di FTX non è in bancarotta e la sua vendita fa parte di un’iniziativa più ampia per aiutare l’exchange in bancarotta a gestire le procedure di rimborso ai suoi creditori. L’approvazione da parte del tribunale arriva meno di due settimane dopo che l’exchange fallito ha annunciato di aver raggiunto un accordo con un’affiliata di Miami International Holdings per vendere LedgerX in un accordo multimilionario.</p>
<p>LedgerX è pronto per essere acquistato da M7 Holdings LLC per $50 milioni a breve.</p>
<h2 id="h2-Tendenze20attuali20del20progetto843155"><a name="Tendenze attuali del progetto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze attuali del progetto</h2><p>In base ai dati forniti da CoinMarketCap, il progetto che ha registrato il maggior aumento nella scorsa settimana è stato KIWIGO (KGO), un asset che funge da token nativo per la piattaforma di servizi commerciali KIWIGO. Di conseguenza, KGO è aumentato del 613,10% nelle ultime 24 ore e del notevole 490,86% nella scorsa settimana.</p>
<h2 id="h2-La20tendenza20attuale20di20BTC103415"><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/16832583832.png" alt=""><br>Settimanale <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo btc</a> Dati (Dati forniti da Coinmarketcap)</p>
<p>Durante la scorsa settimana, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La valutazione di ‘s è diminuita del 0,75% dopo una settimana ostacolata da una significativa volatilità che l’ha mandata sopra e sotto la sua soglia SMA a 7 giorni e tra le zone $27,8k e $29,8k. All’inizio della settimana era di circa $29,53k. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> immediatamente decelerato e affondato a circa $29k, precipitando bruscamente sotto la sua SMA a 7 giorni prima di scendere ulteriormente nella zona superiore di $27.8k. Non è stato fino alle ultime ore del 4 che BTC ha iniziato a riprendersi e ad avvicinarsi alla soglia di $28.8k e a scambiare a una media di $29.1k - ma è comunque rimasto al di sotto della sua SMA a 7 giorni. Tuttavia, con questa maggiore volatilità e traiettoria di trading negativa, è plausibile che BTC possa ulteriormente declinare nella prossima settimana.</p>
<p>Alla luce di questo, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Il MVRV (valore di mercato al valore realizzato) di ‘ è aumentato bruscamente a metà settimana, ma è sceso ripidamente per il resto della settimana. è continuato a diminuire durante la settimana scorsa. Iniziando la settimana a 1.446, è salito a un massimo settimanale il 2 ° a 1.45, prima di diminuire bruscamente durante il resto della settimana e chiudere a 1.447. Tuttavia, nonostante questa diminuzione, il MVRV di BTC rimane solo leggermente inferiore alla settimana precedente, suggerendo che la valutazione di BTC continui a allontanarsi dal territorio sottovenduto e che il suo vero valore si stia realizzando.<br><img src="https://gimg2.gateimg.com/image/article/16832583723.png" alt=""><br>Dati MVRV BTC a 7 giorni (Dati gentilmente forniti da Blockchain.com)</p>
<h2 id="h2-La20situazione20dello20staking20di20ETH924895"><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 5 maggio, lo stato di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> lo staking rimane positivo, il che può essere attribuito all’impressionante performance dei prezzi nel mese scorso, che lo ha portato ad aumentare di oltre il 10%. Questo aumento avviene alla luce dell’ultima implementazione dell’aggiornamento di Shanghai, che ha permesso a tutti i validatori con staking <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> per riscattare progressivamente i loro token e il rendimento successivo guadagnato. Ciò ha portato ad un aumento del prezzo prima dell’implementazione e immediatamente dopo, così come un miglioramento nel sentimento della comunità. Tuttavia, con ETH che oscilla tra le zone superiori di $1,8k e inferiori di $1,9k, sembra che ETH stia venendo spinto verso il basso dalla zona di resistenza di $2k, con ETH che non riesce a testare completamente questa zona nelle ultime settimane. Ciò suggerisce che le conseguenze positive dell’Upgrade di Shanghai potrebbero iniziare a vacillare.<br><img src="https://gimg2.gateimg.com/image/article/16832584134.png" alt=""><br>(Dati forniti da Dune)</p>
<p>Ecco alcuni dati chiave della scorsa settimana per consolidare questo:</p>
<p>Validatori totali: 620.473<br>Indirizzi dei depositanti: 90.200<br>Totale ETH depositati: 16.353.927<br>Percentuale di staking liquido: 33,84%<br>Quota di ETH con staking: 16,77%</p>
<h2 id="h2-La20situazione20macro20attuale586328"><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-Gli20economisti20si20aspettano20un20rimbalzo20economico20in20Asia235002"><a name="Gli economisti si aspettano un rimbalzo economico in Asia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli economisti si aspettano un rimbalzo economico in Asia</h3><p>Poiché gli economisti sono divisi sulla ripresa economica globale, molti analisti hanno confermato di aspettarsi che la ripresa economica sia più probabile in Asia. Alcuni analisti attribuiscono questo alla prossima riapertura della Cina, che si prevede guiderà un significativo rimbalzo per il paese e rafforzerà ulteriormente l’attività economica in tutto il continente. Più del 90% dei capi economisti si aspetta una crescita almeno moderata sia nell’Asia orientale e nel Pacifico che nel Sud dell’Asia. Tuttavia, tre quarti dei capi economisti si aspettano ancora una crescita debole o molto debole in Europa, sottolineando così la disparità geografica nelle prestazioni economiche globali quest’anno.</p>
<h2 id="h2-La20tendenza20attuale20di20Web3931931"><a name="La tendenza attuale di Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La tendenza attuale di Web3</h2><p>L’industria <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> sta vivendo un boom senza precedenti negli ultimi mesi, con l’aumento della tecnologia AI, delle piattaforme crittografiche interoperabili e dell’integrazione delle piattaforme Web2 in Web3, tutto ciò sta spingendo una crescita sostanziale per l’industria Web3. Questo attuale interesse per Web3 è stato ribadito al Consensus 2023, dove le aziende e i magnati hanno manifestato il loro interesse per Web3, nonostante le crescenti sfide regolamentari americane su Web3.</p>
<p>La conferenza annuale sulla blockchain ha attirato oltre 15.000 partecipanti, 220 sponsor e 410 relatori ad Austin, in Texas, dimostrando così che, nonostante il giro di vite degli Stati Uniti sull’adozione delle criptovalute e la limitazione sistematica della crescita delle società di criptovalute statunitensi, molti rimangono ancora entusiasti della tecnologia e della sua utilità. Caitlin Long, fondatrice e CEO di Custodia Bank, ha affrontato la questione in un’intervista con Cointelegraph, affermando: “Abbiamo già visto durante gli inverni delle criptovalute in cui il consenso è stato invaso da persone e aziende con una preferenza temporale elevata (ad esempio, diverse Lambo parcheggiate davanti all’Hilton di New York nel 2018), e negli anni della crisi le persone e le aziende con preferenza temporale bassa continuano a crescere. Quest’anno è stato l’ultimo”.</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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti gli altri casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>