Tm90aXppZSBnaW9ybmFsaWVyZSB8IEJUQyBIYWx2ZWQgQmxvY2sgaGEgcGFnYXRvIHVsdGVyaW9yaSAkMi40TSBpbiBjb21taXNzaW9uaSBkaSByaWNvbXBlbnNhOyBNZXJsaW4gQ2hhaW4gaGEgbGFuY2lhdG8gaWwgdG9rZW4gTUVSTDsgTWFyaW5hZGUgREFPIGhhIHByb3Bvc3RvIGRpIGFsbG9jYXJlIDUwTSBNTkRFcw==

2024-04-22, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/171375825522.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20di20Crypto20il20blocco20dimezzato20di20Bitcoin20ha20pagato20un20costo20aggiuntivo20di20premi20di202420milioni20lanciato20il20token20MERL20di20Merlin20Chain20Marinade20DAO20ha20proposto20di20allocare205020milioni20di20MNDE763141"><a name="Riassunto giornaliero di Crypto: il blocco dimezzato di Bitcoin ha pagato un costo aggiuntivo di premi di $2,4 milioni; lanciato il token MERL di Merlin Chain; Marinade DAO ha proposto di allocare 50 milioni di MNDE." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero di Crypto: il blocco dimezzato di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ha pagato un costo aggiuntivo di premi di $2,4 milioni; lanciato il token MERL di Merlin Chain; Marinade DAO ha proposto di allocare 50 milioni di MNDE.</h2><p>Prima, diamo un’occhiata a <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Attività di trading degli ETF. Secondo i dati di Farside Investor, il 22 aprile, gli ETF spot Grayscale Bitcoin (GBTC) hanno registrato un deflusso di fondi di $45,8 milioni. Nel frattempo, l’afflusso degli ETF spot Fidelity Bitcoin (FBTC) è stato di $54,8 milioni, l’afflusso degli ETF spot Bitwise Bitcoin (BITB) è stato di $4,9 milioni, l’afflusso degli ETF spot ARK 21Shares Bitcoin (ARKB) è stato di $12,5 milioni e l’afflusso netto degli ETF spot iShares Trust Bitcoin (IBIT) è stato di $29,3 milioni.</p>
<p>Dopo cinque giorni consecutivi di perdite, gli investimenti nel mercato degli ETF di Bitcoin hanno registrato un flusso netto positivo prima che Bitcoin si dimezzasse. Si prevede che il valore di mercato di Bitcoin aumenterà dopo il dimezzamento, e le strategie di investimento globali suggeriscono di aggiungere Bitcoin ai portafogli di investimento esistenti. Il mercato degli ETF di Bitcoin riflette questo mentre pone fine all’uscita continua di fondi dal 12 aprile.</p>
<p>Confermare il quarto blocco dimezzato di Bitcoin è importante rispetto alla rete Bitcoin e all’intera industria delle criptovalute. Attraverso la riduzione a metà, l’offerta di Bitcoin viene dimezzata, il che significa che le ricompense per il mining di Bitcoin vengono dimezzate, influenzando così il tasso di inflazione e il tasso di crescita dell’offerta di Bitcoin.</p>
<p>Secondo il browser blockchain, questo blocco dimezzato sembra provenire dal pool di mining ViaBTC e i minatori hanno ricevuto una ricompensa di circa 37,6256 BTC attraverso il mining come pagamento per la verifica e l’elaborazione di 3050 transazioni nel blocco. Questo numero riflette le attività di trading sulla rete Bitcoin e l’importanza dei minatori che vi contribuiscono.</p>
<p>Il lancio del token nativo di Merlin Chain, MERL, segna un momento critico nello sviluppo del progetto. Come un importante miglioramento della rete Bitcoin, Merlin Chain mira a promuovere lo sviluppo delle applicazioni decentralizzate (DApps), che coprono vari settori, tra cui finanza decentralizzata (DeFi), giochi e piattaforme sociali.</p>
<p>Sin dal suo debutto nel febbraio 2024, Merlin Chain ha sperimentato una crescita esplosiva, con un valore totale bloccato (TVL) di oltre 3,6 miliardi di dollari, ed ha incubato un ecosistema vibrante con oltre 200 native DApps. Il lancio di MERL offre opportunità di governance, sicurezza e sviluppo dell’ecosistema migliorate per gli utenti di Merlin Chain.</p>
<p>I token MERL operano secondo lo standard blockchain compatibile con Bitcoin BRC-20, con un’offerta totale di 2,1 miliardi. Tra questi, il 20% dell’offerta totale di token verrà distribuito gratuitamente ai partecipanti tramite l’evento Merlin’s Seal. Questo evento ha registrato un impressionante TVL di 3,6 miliardi di dollari, con il 91% dei finanziamenti provenienti dalla comunità Bitcoin, compresi 1,75 miliardi di dollari in BTC e 980 milioni di dollari in asset BRC-20. Il forte sostegno della comunità Bitcoin è fondamentale per la rapida crescita e l’espansione di Merlin Chain negli ultimi mesi.</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Il protocollo di staking Marinade DAO ha proposto una nuova proposta per sbloccare 50 milioni di token MNDE per l’attività di ricompensa “Marinade Earn Season 3”. La principale differenza tra la Stagione 3 e le precedenti Stagioni 1-2 è che si concentrerà maggiormente sullo approfondimento della liquidità on-chain di mSOL, una debolezza relativa di Marinade nel protocollo SOL LST rispetto ad altri protocolli come Jito.</p>
<p>In particolare, la proposta propone di allocare 25 milioni di MNDE implementando una strategia su Solend, aumentando così la redditività del ciclo di staking da Meteora mSOL/SOL rispetto alle attuali piscine di mSOL (come Solend e Kamino) e ad altri SOL LST, approfondendo quindi la liquidità di mSOL in DeFi.</p>
<p>Inoltre, la proposta suggerisce anche di allocare ulteriori 25 milioni di MNDE per incentivare l’abbinamento dei token dell’ecosistema <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> esistenti e futuri con mSOL, incorporando così ulteriormente mSOL nell’economia di Solana e approfondendone la liquidità.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20ha20completato20lhavling20e20il20mercato20sta20vivendo20ampie20fluttuazioni218757"><a name="Tendenze di mercato: BTC ha completato l’havling e il mercato sta vivendo ampie fluttuazioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC ha completato l’havling e il mercato sta vivendo ampie fluttuazioni</h2><p>La scorsa notte di venerdì, Bitcoin è brevemente sceso al di sotto dei 60.000 dollari, ma dopo aver completato il suo quarto halving di Bitcoin sabato mattina, il prezzo è rimbalzato a 65.000 dollari. Nel complesso, il mercato cripto sta mostrando una vasta gamma di fluttuazioni, e in questa ondata di rimbalzo, il settore Meme è stato il più attivo.</p>
<p>Per quanto riguarda la macroeconomia, il mercato azionario degli Stati Uniti ha subito un forte calo, con Nvidia che ha registrato il suo più grande calo degli ultimi quattro anni. Secondo i dati osservati dalla Federal Reserve del CME, la probabilità che la Fed mantenga invariati i tassi di interesse a maggio è del 96,2%, mentre la probabilità di un taglio dei tassi di 25 punti base cumulativo è del 3,8%.</p>
<h3 id="h3-Punti20Caldi20del20Mercato987636"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><p>Settore dei meme ripresa: Durante la ripresa del fine settimana, i token come BONK, PEPE e FLOKI hanno ottenuto le performance più brillanti, con un aumento medio di oltre il 20%. Tra questi, BONK ha proposto una proposta di distruzione. Ciò è coerente con le aspettative precedenti, poiché i token nel settore dei meme di solito si riprendono più velocemente dopo una diminuzione del mercato.</p>
<p>Rune e token correlati: le iscrizioni come SATS e RATS hanno mostrato qualche performance nel rimbalzo di mercato, mentre runestone, il leader delle rune, è collassato; i suoi airdrop non hanno coperto il suo declino. Le aspettative generali per le rune concorrenti sono basse, con alti limiti operativi e costi gas on-chain, il che ha portato a un gran numero di utenti scoraggiati. Le rune permettono alle parti del progetto di pre-estrarre, il che non è abbastanza decentralizzato e giusto, e la giustizia è un vantaggio principale del settore meme.</p>
<p>Il concetto di AI+Depin: io.net ha rilasciato un sistema di integrazione e attualmente è nella fase di test beta. Il progetto prevede di essere distribuito in futuro e gli investitori dovrebbero prestare attenzione al suo ulteriore sviluppo e annunci per cogliere opportunità di investimento potenziali.</p>
<p>Complessivamente, anche se il mercato è volatile, il settore dei Meme mostra ancora un forte slancio di mercato. Dopo la riduzione a metà del BTC, attualmente vengono prodotti circa 450 BTC al giorno. Gli investitori dovrebbero continuare a monitorare le tendenze macroeconomiche e le notizie specifiche del settore per prendere decisioni di investimento tempestive.</p>
<h2 id="h2-Macro20lindice20di20Wall20Street2020sceso20venerd20ci20si20aspetta20che20il20mercato20asiatico20faccia20una20ripresa20loro20e20il20petrolio20sono20leggermente20diminuiti679202"><a name="Macro: l’indice di Wall Street è sceso venerdì, ci si aspetta che il mercato asiatico faccia una ripresa, l’oro e il petrolio sono leggermente diminuiti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: l’indice di Wall Street è sceso venerdì, ci si aspetta che il mercato asiatico faccia una ripresa, l’oro e il petrolio sono leggermente diminuiti</h2><p>Venerdì scorso, gli indici Nasdaq e S&amp;P 500 hanno chiuso al ribasso, ma l’indice Dow Jones è rimasto stabile, influenzato principalmente dai rapporti finanziari trimestrali di American Express. Il sentiment di mercato è stato ulteriormente indebolito dalla sentiment pessimistica che la Federal Reserve potrebbe non abbassare i tassi di interesse presto.</p>
<p>L’oro e il sicuro rifugio dei dollari USA sono scesi dai massimi vicini, e i prezzi del petrolio sono anche scesi. A Wall Street, l’indice S&amp;P 500 ha registrato il suo più lungo declino consecutivo da ottobre 2022. Nvidia nel settore tecnologico è crollata del 10%, trascinando al ribasso l’indice NASDAQ, mentre la domanda di titoli del Tesoro, oro e franchi svizzeri rifugio è aumentata.</p>
<p>In particolare, l’indice Dow Jones è salito dello 0,56%, mentre l’indice S&amp;P 500 è sceso dell’0,88% e l’indice Nasdaq è sceso del 2,05%. Gli indici S&amp;P e NASDAQ sono in calo da sei giorni di contrattazione consecutivi, segnando il trend al ribasso più lungo da ottobre 2022. Anche se le azioni legate ai chip sono diventate una delle migliori azioni quest’anno a causa della loro associazione con l’intelligenza artificiale, l’indice dei semiconduttori di Philadelphia è sceso in modo significativo.</p>
<p>Nel mercato asiatico, ci si aspetta che lunedì si riprenda dalla flessione della settimana scorsa, con i rendimenti obbligazionari in aumento. Tuttavia, a causa dei commenti hawkish dalla Federal Reserve, delle tensioni in Medio Oriente e delle azioni tecnologiche deboli, il recupero di lunedì non è facile.</p>
<p>Il prezzo delle azioni di TSMC è sceso del 6,7% venerdì prima della pubblicazione del suo rapporto finanziario del primo trimestre. I dati e le conclusioni sono state inaspettate in quanto l’azienda ha ridotto le aspettative di crescita nel settore dei chip e non ha revisionato il piano di spesa iniziale. Nonostante ciò, come il più grande produttore di chip OEM al mondo, TSMC si aspetta che le sue vendite crescano fino al 30% nel secondo trimestre, trainate dall’aumento della domanda di chip nelle applicazioni di intelligenza artificiale. Inoltre, il profitto del primo trimestre di TSMC ha superato anche le aspettative.</p>
<p>Nelle prime ore di trading asiatico di lunedì, l’euro e lo yen sono rimasti relativamente stabili, mentre il dollaro statunitense è rimasto vicino ai massimi dopo le tensioni della scorsa settimana legate alle politiche e agli sviluppi geopolitici. Questa settimana, il mercato è concentrato sullo yen giapponese e la revisione delle politiche da parte della Banca del Giappone (BOJ) di venerdì è diventata un elemento essenziale del calendario economico.</p>
<p>Nonostante le notizie dell’attacco israeliano, l’indice azionario dell’Asia Pacifica è salito dello 0,93%, mentre l’indice Nikkei in Giappone è salito dello 0,48%. Tuttavia, a causa dell’alta concentrazione di azioni nell’industria dei chip, le prestazioni del mercato azionario giapponese sono inferiori rispetto a quelle delle altre regioni.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio greggio sono diminuiti poiché gli operatori tornano a concentrarsi sui fondamentali. In risposta all’aumento delle scorte negli Stati Uniti, i futures del petrolio Brent sono scesi di 54 centesimi, pari allo 0,6%, a $86,75 al barile.</p>
<p>Il contratto di petrolio greggio West Texas Intermediate (WTI) di maggio scade lunedì ed è sceso di 12 centesimi a $83,02 al barile. Il contratto di giugno, più attivo, è sceso di 47 centesimi, o dello 0,6%, a $81,75 al barile.</p>
<p>Il prezzo dell’oro è sceso a $2,376.40.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Icing</strong>, Ricercatore di 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 su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>