Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgbWVyY2F0byBmbHV0dHVhIHZlcnNvIGwnYWx0bzsgU3RhY2tzIGluaXppYSBsYSAiUmlmb3JtYSBOYWthbW90byI7IFBheVBhbCBpbmNlbnRpdmEgaSAibWluYXRvcmkgdmVyZGkiOyBOZXVyYSByaWxhc2NpYSBpbCB0ZXN0bmV0IHB1YmJsaWNv

2024-04-23, 03:48

<p><img src="https://gimg2.gateimg.com/image/article/171384407223.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Stacks20avvia20la20Nakamoto20Reform20PayPal20propone20un20Green20Miner20Incentive20Plan20La20rete20Layer120di20Ankr20Neura20rilascia20il20testnet20pubblico260309"><a name="Crypto Daily Digest: Stacks avvia la “Nakamoto Reform”; PayPal propone un “Green Miner Incentive Plan”; La rete Layer1 di Ankr, Neura, rilascia il testnet pubblico" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: <a href="/price/stacks-stx" target="_blank" class="blog_inner_link">Stacks</a> avvia la “Nakamoto Reform”; PayPal propone un “Green Miner Incentive Plan”; La rete Layer1 di Ankr, Neura, rilascia il testnet pubblico</h2><p>Innanzitutto, diamo un’occhiata all’attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Secondo i dati di Farside Investor, il 22 aprile i fondi spot ETF GBTC di Grayscale sono usciti per 35 milioni di dollari; nel frattempo, i fondi spot ETF di iShares Trust <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (IBIT) sono entrati per 19,7 milioni di dollari; i fondi spot ETF di Fidelity Bitcoin (FBTC) sono entrati per 34,8 milioni di dollari, i fondi spot ETF di Bitwise Bitcoin (BITB) sono entrati per 2,2 milioni di dollari e i fondi spot ETF di ARK 21Shares Bitcoin (ARKB) sono entrati per 22,6 milioni di dollari.</p>
<p><a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a> Il blockchain sta per subire una grande riforma chiamata “Nakamoto”, che è un omaggio agli anonimi creatori di Bitcoin. La riforma inizierà dall’altezza del blocco Bitcoin a 840.360 e sarà divisa in due fasi, previste per essere completate alla fine di maggio. Questa riforma mira a separare il piano di produzione dei blocchi di Stacks da quello di Bitcoin.</p>
<p>Secondo Muneeb Ali, il creatore della rete Stacks, CoinDesk, sebbene la capacità di transazione della rete Layer 2 sia superiore a quella di Bitcoin (elaborando circa sette transazioni al secondo), secondo il progetto iniziale, Stacks aveva la stessa velocità di output del blocco di Bitcoin, il che ha causato problemi di congestione.</p>
<p>Attualmente, il valore degli STX messi in gioco sulla catena è di circa 1,3 miliardi di dollari, pari a un terzo della fornitura circolante totale di 4,2 miliardi di dollari, rendendolo uno dei più grandi pool di capitale a interesse correlati a Bitcoin. Nelle ultime 24 ore, il prezzo di questo token è aumentato di oltre il 16%, entrando per la prima volta tra i primi 25 token per valore di mercato.</p>
<p>PayPal ed EnergyWeb stanno collaborando per sviluppare una soluzione che premia i minatori di Bitcoin per l’uso di energia a basso contenuto di carbonio nelle loro operazioni.</p>
<p>PayPal ha dichiarato oggi sul suo blog che il loro team di ricerca sul blockchain ha collaborato con l’organizzazione non profit EnergyWeb per sviluppare una piattaforma di verifica dell’energia pulita per monitorare e premiare le imprese di mining di Bitcoin a basso consumo energetico. Lo sviluppo di questa soluzione arriva in un momento in cui il mining di Bitcoin sta mettendo enormi pressioni sulle reti elettriche locali e sui contribuenti negli Stati Uniti.</p>
<p>Il mining di Bitcoin è un processo in cui i minatori utilizzano computer di grandi dimensioni che consumano energia. La soluzione proposta da PayPal distribuirà Bitcoin ai miner di Bitcoin “verdi”, che utilizzano energia a basse emissioni di carbonio nelle operazioni di mining. La National Oceanic and Atmospheric Administration degli Stati Uniti afferma che l’utilizzo di metodi di estrazione a basse emissioni di carbonio può limitare le emissioni di carbonio e rallentare il riscaldamento globale.</p>
<p>Il <a href="/price/ankr-ankr" rel="nofollow noopener noreferrer" target="_blank">Ankr</a> Il team di Protocol Village ha annunciato che la loro catena AI di livello 1 “Neura” è stata rilasciata nella rete di test pubblica. Questa rete di test è costruita su Cosmos SDK ed è compatibile con <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Virtual Machine (EVM). Neura mira a fornire una piattaforma per sviluppatori che desiderano sviluppare dApp che integrano intelligenza artificiale e Web3.</p>
<p>Neura ha affrontato le sfide chiave delle startup di intelligenza artificiale, come garantire il finanziamento, acquisire risorse GPU e memorizzare efficacemente i dati attraverso innovative combinazioni di tecnologia. Il programma “Road To Mainnet” di Neura includerà una competizione per sviluppatori, con i migliori progetti che riceveranno $100.000 di finanziamento. Inoltre, Neura fornirà anche premi ai detentori di token ANKR, tra cui vantaggi unici come l’opportunità di investire in nuovi token di modelli di intelligenza artificiale.</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato20delle20criptovalute2020in20fluttuazione20al20rialzo20e20la20moneta20Meme20sta20performando20in20modo20forte131565"><a name="Tendenze di mercato: il mercato delle criptovalute è in fluttuazione al rialzo e la moneta Meme sta performando in modo forte" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato delle criptovalute è in fluttuazione al rialzo e la moneta Meme sta performando in modo forte</h2><p>Oggi, il mercato crittografico mostra un trend al rialzo volatile, con i settori Meme e LSD che guidano il mercato nelle prestazioni. Nel mercato dei contratti, entrambi i tassi di BTC ed ETH mostrano valori negativi, indicando che il sentiment di mercato potrebbe essere eccessivamente pessimistico, il che potrebbe indicare un potenziale punto di svolta nelle tendenze di mercato.</p>
<p>Per quanto riguarda la macroeconomia, il mercato azionario statunitense ha ripreso dopo sei cali consecutivi. Tuttavia, le prestazioni della stagione dei bilanci finanziari non sono ideali, il che potrebbe avere un certo impatto sul sentiment del mercato delle criptovalute.</p>
<h3 id="h3-Punti20caldi20del20mercato813144"><a name="Punti caldi del mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi del mercato:</h3><p>Il settore Meme ha registrato guadagni significativi: token come PEPE, MOG, SLERF e FOXY hanno registrato aumenti significativi. Essendo il motore della precedente fase del mercato Meme, PEPE ha nuovamente preso il comando nel lancio, indicando che potrebbe guidare una nuova fase del mercato Meme. Inoltre, Slerf ha completato un rimborso da un milione di dollari alle vendite private dei token, il che ha stimolato un aumento significativo del suo prezzo.</p>
<p>Anche i token di staking di liquidità hanno mostrato una forte performance: PENDLE, ANKR, SSV e altri token sono aumentati significativamente. I dati on-chain indicano che molti PENDLE sono stati ritirati di recente dagli exchange, con un valore totale di oltre $11 milioni. Questa grande quantità di denaro <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> potrebbe indicare a lungo termine <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> verso questi token.</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Follia dei token Meme on-chain: MANEKI ha raggiunto una crescita del prezzo di 300 volte poco dopo il lancio, con un valore di mercato superiore a 100 milioni di dollari. Il token Meme dell’immagine del gatto è stato spesso esaltato nel mercato di recente, e il progetto Maneki ha aumentato significativamente la sua attenzione sui social media.</p>
<p>L’ecosistema BTC ha avuto prestazioni deludenti: sia il progetto rune che il BTC Layer2 non hanno ottenuto i risultati attesi, e l’intero ecosistema BTC ha generalmente sperimentato un brusco declino in tempi recenti. Dopo il passaggio dell’evento di halving BTC, l’attenzione del mercato potrebbe spostarsi verso altre aree più promettenti.</p>
<p>Sebbene il mercato mostri un trend al rialzo fluttuante, c’è una chiara differenziazione tra settori diversi. Il settore Meme e alcuni progetti di staking di liquidità hanno dimostrato un’attività di mercato forte e un interesse degli investitori, mentre l’ecosistema correlato a BTC affronta una pressione significativa. Gli investitori dovrebbero considerare la diversificazione dei rischi quando partecipano al mercato e prestare attenzione all’impatto potenziale del sentiment di mercato e dei fattori macroeconomici sul mercato crittografico.</p>
<h2 id="h2-Macro20I20mercati20globali20hanno20mostrato20un20iniziale20recupero20dopo20una20settimana20di20calo187575"><a name="Macro: I mercati globali hanno mostrato un iniziale recupero dopo una settimana di calo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I mercati globali hanno mostrato un iniziale recupero dopo una settimana di calo</h2><p>Il 22 aprile, la borsa di Wall Street ha chiuso in rialzo poiché gli investitori si sono concentrati sui risultati trimestrali delle principali società di questa settimana per capire la salute dell’economia degli Stati Uniti. Alla chiusura, l’indice Dow Jones è salito dello 0,67%, l’indice Standard&amp;Poor’s è salito dell’0,87% e l’indice Nasdaq è salito dell’1,11%.</p>
<p>Le grandi azioni tecnologiche hanno avuto buone prestazioni prima di annunciare i risultati trimestrali di questa settimana, facendo salire l’indice Nasdaq. I prezzi delle azioni di Alphabet, Amazon e Apple sono aumentati tra lo 0,5% e l’1,5%, mentre Nvidia è salita del 4,4%, recuperando dal calo del 10% nella precedente giornata di negoziazione.</p>
<p>Oltre al monitoraggio della redditività delle principali aziende, il mercato è ancora in attesa della pubblicazione dei dati del PIL degli Stati Uniti e dei dati di spesa personale di marzo in questa settimana. Questi dati sono cruciali per determinare la traiettoria della politica monetaria, specialmente il suo impatto sulla Federal Reserve.</p>
<p>Sul fronte europeo, il Ministro dell’Economia italiano ha dichiarato che si prevede che la Banca Centrale Europea inizi a ridurre i tassi di interesse nella seconda metà del 2024. Questa notizia ha avuto un certo impatto sul mercato, specialmente sul flusso di credito bancario.</p>
<p>Il 23 aprile, supportati dal recupero delle azioni tecnologiche, dai mercati dei redditi fissi tranquilli e dal raffreddamento delle tensioni geopolitiche, i mercati azionari globali hanno aperto positivamente lunedì e ci si aspetta che i mercati azionari asiatici si riprendano martedì. Influenzati da Wall Street, i mercati azionari asiatici hanno continuato la loro tendenza al rialzo oggi. La focalizzazione di questa settimana si è spostata sui risultati di redditività dei giganti tecnologici americani, con il dollaro americano che rimane forte come valuta, facendo sì che lo yen giapponese raggiunga un minimo di 34 anni.</p>
<p>Con la continua diffusione e sviluppo delle applicazioni di intelligenza artificiale, aziende tecnologiche come TSMC potrebbero beneficiare di questa tendenza, stimolando così il rialzo dei prezzi delle azioni. Si prevede che il prezzo delle azioni di TSMC si riprenda dal calo del 6% di venerdì e si riprenda dal calo dell’1% di lunedì. Secondo i dati ufficiali di Taipei, il tasso di crescita degli ordini di esportazione a marzo è stato inferiore alle aspettative. Tuttavia, il governo ha comunque fiducia nell’impennata della domanda di applicazioni di intelligenza artificiale, che guiderà la crescita futura della domanda di prodotti ad alta tecnologia a Taiwan.</p>
<p>Con la continua diffusione e sviluppo delle applicazioni di intelligenza artificiale, le aziende tecnologiche come TSMC potrebbero beneficiare di questa tendenza, spingendo così il rialzo dei prezzi delle azioni.</p>
<p>Il calendario economico di martedì è piuttosto ricco, con i rapporti sull’indice dei manager degli acquisti dal Giappone, dall’Australia e dall’India, i rapporti sull’inflazione dei consumatori da Singapore e Hong Kong, i rapporti sull’inflazione dei produttori dalla Corea del Sud e i rapporti sulla produzione industriale da Taiwan.</p>
<p>Per quanto riguarda le materie prime, mentre gli investitori continuano a valutare la situazione in Medio Oriente, i prezzi del petrolio si sono ripresi da significativi cali durante la notte. I futures del petrolio greggio Brent sono saliti dello 0,2% a $87,16 al barile, mentre i futures del petrolio greggio statunitense sono saliti dello 0,2% a $82,06 al barile.</p>
<p>Dopo essere sceso del 2,7% durante la notte, il prezzo dell’oro ha continuato a scendere del 1% a $2.295,9 per oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Icing</strong>, Ricercatore Gate.io<br><div>Traduttore: Joy Z.<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 di questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che sia citato Gate.io. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>