Tm90aXppZSBxdW90aWRpYW5lIHwgSlBNb3JnYW4gZGljZSBjaGUgQlRDIGNhZHLDoCB2ZXJzbyBpIDQyLjAwMCBkb2xsYXJpOyBTbGVyZiBjb21wbGV0YSBpbCBwcmltbyByaW1ib3JzbyBkaSAzLjgwMCBTT0w7IElsIHByb2dldHRvIGRpIGdpb2NvIEJsYXN0IHJhZGRvcHBpYSBpIGZvbmRpIGRlZ2xpIHV0ZW50aSBhIGNhdXNhIGRpIHV

2024-03-22, 03:32

<p><img src="https://gimg2.gateimg.com/image/article/17110896441_16.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20JPMorgan20afferma20che20BTC20cadr20verso20i204200020Slerf20e20LBank20completano20il20primo20rimborso20di20un20totale20combinato20di20380020SOL20Il20progetto20Blast20Gaming20raddoppia20i20fondi20propri20degli20utenti20a20causa20di20una20vulnerabilit307131"><a name="Crypto Daily Digest: JPMorgan afferma che BTC cadrà verso i $42.000; Slerf e LBank completano il primo rimborso di un totale combinato di 3.800 SOL; Il progetto Blast Gaming raddoppia i fondi propri degli utenti a causa di una vulnerabilità" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: JPMorgan afferma che BTC cadrà verso i $42.000; Slerf e LBank completano il primo rimborso di un totale combinato di 3.800 SOL; Il progetto Blast Gaming raddoppia i fondi propri degli utenti a causa di una vulnerabilità</h2><p>Prima di tutto, esaminiamo le attività di trading degli ETF Bitcoin. Secondo i dati di Farside Investor, il 21 marzo, il Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) ha registrato deflussi per 358,8 milioni di dollari; il Fidelity Bitcoin Spot ETF (FBTC) ha registrato deflussi per 2,9 milioni di dollari; il Bitwise Bitcoin Spot ETF (BITB) ha registrato afflussi per 12 milioni di dollari; e l’ARK 21Shares Bitcoin Spot ETF (ARKB) ha registrato afflussi per 2 milioni di dollari.</p>
<p>Gli analisti di JPMorgan hanno detto che anche se <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ha subito un rapido ritracciamento la settimana scorsa e si è ripreso questa settimana, ma rimane in una zona di “ipervenduto”, suggerendo che potrebbe cadere ulteriormente.</p>
<p>A lungo termine, il mercato è notevolmente ottimista che i prezzi del bitcoin aumenteranno entro la fine dell’anno a causa delle aspettative di una continua crescita della domanda di ETF spot, ma un ritracciamento a breve termine è inevitabile. La scorsa settimana, gli analisti hanno previsto che il prezzo del bitcoin potrebbe scendere a circa $42.000 dopo l’halving, citando, tra le altre cose, una riduzione degli incentivi per i minatori e un aumento dei costi di produzione.</p>
<p>Gli analisti hanno concluso: “È probabile che i profitti del Bitcoin continuino mentre si avvicina il quarto halving, specialmente considerando che sembra ancora ipercomprato nonostante la correzione della settimana scorsa.”</p>
<p>La memecoin Slerf su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> è stato ampiamente discusso perché lo sviluppatore ha bruciato accidentalmente i token mentre diceva che avrebbe rimborsato i partecipanti. Slerf e il team di LBank si sono uniti per raccogliere quasi 4.000 <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> (SOL) in 24 ore. Secondo i dati on-chain, 3.800 di questi sono stati rimborsati ai piccoli utenti che hanno partecipato alle prime fasi della donazione di Slerf.</p>
<p>Al momento, le donazioni in prevendita per Slerf sono ancora in corso. Il team di Slerf ha dichiarato che effettueranno premi airdrop per gli utenti dopo la conclusione della donazione, ma il contenuto dell’airdrop non è stato ancora annunciato.</p>
<p>In seguito, il modello di “donazione in pre-vendita” ha alimentato l’attività dei progetti meme ma ha anche portato al caos. Ad esempio, il progetto “OrbitX” su MerlinChain ha aggiunto LP alla maggior parte del fundraising e la quota di token airdrop è stata ridotta al 2,5%. Tuttavia, solo due ore dopo l’apertura della sessione di trading, l’indirizzo del progetto ha ritirato tutti i fondi dal pool LP e cancellato l’account della piattaforma X, riducendo il valore dei token a zero.</p>
<p>Infine, un progetto sulla rete Blast - un gioco Telegram chiamato Super <a href="/price/sushi-sushi" rel="nofollow noopener noreferrer" target="_blank">Sushi</a> Samurai è stato attaccato sfruttando una vulnerabilità. Un sviluppatore di smart contract presso Yuga Labs ha evidenziato che c’era un bug nel contratto per il token SSS. Se un utente trasferiva l’intero saldo del proprio portafoglio a se stesso, i loro fondi sarebbero stati raddoppiati.</p>
<p>Gli attaccanti hanno approfittato di ciò e hanno venduto i token appena coniati per 1.310 Ether confezionati, utilizzando quei fondi per svuotare la liquidità dallo scambio decentralizzato. Ciò ha comportato una perdita di 4,6 milioni di dollari per il progetto al prezzo prente.</p>
<p>C’è stata comunque un’imprevista evoluzione di questa storia. Il progetto ha dichiarato che gli aggressori li hanno contattati e che si è trattato di un hack white hat. L’altra parte ha fornito i dettagli di contatto e ha affermato che gli utenti dovrebbero essere risarciti. Gli ufficiali del progetto sono stati contattati su Blockscan e potrebbero seguire una collaborazione per risolvere la questione.</p>
<h2 id="h2-Analisi20di20mercato20la20tendenza20generale20del20mercato20continua20a20subire20unajustamento20shock20le20altcoin20sono20in20caduta20generale529774"><a name="Analisi di mercato: la tendenza generale del mercato continua a subire un’ajustamento shock, le altcoin sono in caduta generale." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi di mercato: la tendenza generale del mercato continua a subire un’ajustamento shock, le altcoin sono in caduta generale.</h2><p>Recentemente, le aspettative di taglio dei tassi di interesse della Fed hanno influenzato la tendenza del mercato e la tendenza generale mostra un aggiustamento dopo un forte rimbalzo.</p>
<p>Nel processo, gli Altcoin nel loro complesso hanno mostrato un pattern generale di declino, mentre il netto ETF spot del bitcoin ha mostrato deflussi per quattro giorni di negoziazione consecutivi, suggerendo un sentimento cauto degli investitori. Nel frattempo, le azioni statunitensi hanno registrato un lieve aumento e continuato a segnare nuovi massimi storici, fornendo alcuni segnali ottimistici per il mercato, ma dobbiamo essere cauti di possibili shock ad alto livello.</p>
<h3 id="h3-Punti20Caldi20del20Mercato913470"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><ol>
<li><p>L’ingresso del fondo BlackRock in RWA solleva preoccupazioni: la notizia dell’ingresso del fondo BlackRock nel fondo di tokenizzazione ha continuato a fermentare sul mercato, portando a un’impennata dei token concettuali di RWA come RSR e TRU. Inoltre, POLYX, MKR, ONDO e altri token sono saliti, di cui ONDO ha addirittura raggiunto ieri un record; aumentando di più del 50% in un solo giorno. Questa serie di rialzi mostra che il mercato è ottimista sull’ingresso di istituzioni come BlackRock, ma dobbiamo anche essere vigili sui rischi di eccessiva speculazione.</p>
</li><li><p>Rimbalzo del concetto di Meme: il token del concetto di Meme BOME è rimbalzato bruscamente ed è stato scambiato frequentemente dopo essere stato lanciato su scambi su larga scala. Secondo i dati del Chain Browser, la quantità totale di BOME detenuta sull’indirizzo CEX è superiore al 50%. Allo stesso tempo, il fondatore di BOME, Darkfarm, ha pianificato di lanciare un nuovo progetto di iscrizione, i cui proventi verranno utilizzati per riacquistare i BOME distrutti, una serie di sviluppi che hanno rivitalizzato il sentiment del mercato nei confronti di BOME.</p>
</li><li><p>Protocollo Social Concept Diving: l’ID del protocollo Social Concept ha subito un forte calo e l’organizzazione ha sbloccato e iniziato a spedire. Questo è un tipico sblocco prima del comportamento di spedizione della piastra, simile al comportamento recente di APT, ARB, ecc. Ciò suggerisce che alcuni investitori di mercato hanno scelto di vendere le loro posizioni prima dello sblocco, sia per le preoccupazioni sul valore futuro o per incassare. Questo fenomeno è motivo di preoccupazione e potrebbe influenzare le prestazioni dei token correlati.</p>
</li></ol>
<p>In generale, il mercato è ancora in una fase di adeguamento e gli investitori devono rimanere cauti e prestare attenzione all’evoluzione di ogni mercato caldo controllando il loro rischio per far fronte alla possibile volatilità.</p>
<h3 id="h3-Macro20I20mercati20globali20salgono20mentre20Wall20Street20raggiunge20un20massimo20di20chiusura20sulla20prospettiva20di20un20taglio20dei20tassi20le20azioni20dei20chip20guidano20i20guadagni20Apple20citata20in20giudizio20per20monopolio130663"><a name="Macro: I mercati globali salgono mentre Wall Street raggiunge un massimo di chiusura sulla prospettiva di un taglio dei tassi; le azioni dei chip guidano i guadagni, Apple citata in giudizio per monopolio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I mercati globali salgono mentre Wall Street raggiunge un massimo di chiusura sulla prospettiva di un taglio dei tassi; le azioni dei chip guidano i guadagni, Apple citata in giudizio per monopolio</h3><p>Dopo che la Federal Reserve ha mantenuto i tassi di interesse statunitensi tra il 5,25% e il 5,5%, Powell ha affermato che i recenti dati sull’inflazione non hanno cambiato il quadro sottostante delle pressioni sui prezzi in lento alleggerimento, e ha confermato che l’economia continuerà a crescere ad un ritmo solido.</p>
<p>Attualmente i prezzi di mercato riflettono le aspettative che la Fed e la BCE inizieranno a tagliare i tassi nelle loro riunioni del mese di giugno. I rendimenti dei titoli del Tesoro statunitense sono diminuiti nelle prime negoziazioni prima di aumentare nuovamente a seguito di una riduzione delle richieste settimanali di sussidi di disoccupazione e di un forte rapporto sull’indice degli acquisti manifatturieri.</p>
<p>Giovedì, i tre principali indici azionari di Wall Street hanno raggiunto nuovi massimi di chiusura per il secondo giorno consecutivo dopo che la Federal Reserve ha rassicurato gli investitori sulle prospettive di tagli dei tassi quest’anno, mentre le azioni dei chip sono aumentate dopo una previsione ottimistica di Micron Technology.</p>
<p>Apple Inc. è stata citata in giudizio dal Dipartimento di Giustizia degli Stati Uniti per presunta “monopolizzazione del mercato degli smartphone”. Questa è la prima grande causa antitrust dell’amministrazione Biden contro l’azienda, che ha fatto scendere le azioni del 4,1 percento sul mercato.</p>
<p>Le azioni asiatiche si avvicinavano ai guadagni settimanali venerdì, con il Nikkei che raggiungeva un massimo storico, e le azioni globali salivano dopo un inatteso taglio dei tassi di interesse da parte della banca centrale svizzera che portava gli investitori a scommettere su chi potesse essere il prossimo a tagliare i tassi. La banca centrale svizzera ha tagliato i tassi di interesse di 25 punti base giovedì, iniettando fiducia nei sentimenti di rischio globali mentre i mercati aumentavano le scommesse sul fatto che le grandi banche centrali ridurranno i costi di finanziamento quest’anno, spingendo Wall Street a chiudere ad un massimo storico.</p>
<p>Il Dow Jones Industrial Average (.DJI) è salito di 269,24 punti, o dello 0,68%; lo Standard &amp; Poor’s 500 Index (.SPX) ha guadagnato 16,9 punti, o lo 0,32%; e il Nasdaq Composite Index (.IXIC) è aumentato di 32,43 punti, o dello 0,2%.</p>
<p>Il Nikkei del Giappone (.N225) e l’Indice ponderato di Taiwan (.TWII) sono entrambi saliti del 2% ai massimi storici, mentre l’Indice di equità globale MSCI (.MIWD00000PUS) è salito di 5,28 punti, o dello 0,68%.</p>
<p>Sul fronte delle materie prime, i prezzi del petrolio greggio Brent sono scesi di 43 centesimi a $85.35 al barile, mentre i prezzi del petrolio greggio statunitense sono scesi di 41 centesimi a $80.66 al barile.</p>
<p>Per quanto riguarda i prezzi dell’oro, l’oro spot ha toccato un nuovo record storico giovedì prima di scendere dello 0,28% a $2.174,89 per oncia.</p>
<div class="blog-details-info"><br><div>Autore: <strong> Sherry S. &amp; Icing. </strong>, Ricercatore di Gate.io<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 si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>