Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGUgRVRIIGNvbnRpbnVhbm8gYSBkaW1pbnVpcmU7IFNMRVJGIGhhIGFjY2lkZW50YWxtZW50ZSBicnVjaWF0byB1biBncmFuIG51bWVybyBkaSB0b2tlbiwgbWEgaWwgbWVtZSBkaSBTb2xhbmEgw6ggYW5jb3JhIGNhbGRvOyBsZSBhemlvbmkgdGVjbm9sb2dpY2hlIHN0aW1vbGFubyBsZWdnZXJ

2024-03-19, 03:38

<p><img src="https://gimg2.gateimg.com/image/article/17108194731_13.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20di20Crypto20BTC20ed20ETH20continuano20a20diminuire20SLERF20ha20accidentalmente20bruciato20token20per201020milioni20ma20il20meme20di20Solana2020ancora20caldo673172"><a name="Riassunto giornaliero di Crypto: BTC ed ETH continuano a diminuire; SLERF ha accidentalmente bruciato token per $10 milioni, ma il meme di Solana è ancora caldo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero di Crypto: BTC ed ETH continuano a diminuire; SLERF ha accidentalmente bruciato token per $10 milioni, ma il meme di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> è ancora caldo</h2><p>First, 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 19 marzo i fondi GBTC di Grayscale hanno continuato a <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> significativamente, raggiungendo un massimo di $642,5 milioni questo mese. Nel frattempo, l’afflusso di Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) è stato di $5,9 milioni, l’afflusso di Bitwise Bitcoin spot ETF (BITB) è stato di $17,6 milioni e l’afflusso di ARK 21Shares Bitcoin spot ETF (ARKB) è stato di $2,7 milioni.</p>
<p>Negli ultimi due giorni, BTC ETH ha mostrato un significativo calo. Secondo i dati di Coingecko, BTC è attualmente a $65,754.33, in calo del 3.2% in 24 ore; ETH ha riportato $3,405.20, in calo del 16.2% in 24 ore. Il profitto dei detentori a lungo e breve termine potrebbe essere il fattore più importante, e per Bitcoin, questo è un tipico ritracciamento dei prezzi prima dell’halving. Si osserva che il ritracciamento più probabile avviene 2-3 settimane prima dell’halving.</p>
<p>Osservando la situazione della liquidazione, si può notare che il mercato dei futures di Bitcoin sta vivendo fluttuazioni drastiche. Il momento della liquidazione lunga coincide con un’incremento della volatilità. Entro 24 ore dal 18 marzo, sono state liquidate posizioni lunghe per oltre 40 milioni di dollari. La liquidazione lunga del Bitcoin è salita a oltre 15 milioni di dollari nello stesso giorno entro 4 ore.</p>
<p>Quando i tori di Bitcoin vengono liquidati senza pressione d’acquisto da parte dei trader, il prezzo di Bitcoin ne risente negativamente. Il volume di trading di Bitcoin è diminuito di oltre $25 miliardi rispetto al suo picco di volume di trading giornaliero di $45 miliardi a 3,5 di quest’anno. Questo è anche uno dei motivi della attuale diminuzione del prezzo.</p>
<p>Il prezzo di Bitcoin è influenzato dai guadagni dei detentori, dagli eventi macroeconomici come le azioni normative e dalla politica monetaria della Federal Reserve. Tuttavia, nel lungo periodo, i partecipanti al mercato si aspettano comunque che i prezzi del Bitcoin si riprendano, soprattutto man mano che sempre più istituzioni finanziarie abbracciano Bitcoin.</p>
<p>I contratti di interesse aperto per i future di Bitcoin a marzo hanno raggiunto un massimo storico, passando da $22,2 miliardi il 25 febbraio a $35,5 miliardi il 14 marzo. Inoltre, lo squilibrio nella domanda di leva porta a distorsioni, che sono raramente sostenibili.</p>
<p>Il contratto perpetuo include tassi di interesse che vengono ricalcolati ogni otto ore. Un tasso di interesse di finanziamento positivo indica una crescente domanda di leva finanziaria da parte di coloro che detengono posizioni long. Cointelgraph ha riportato che il 15 marzo, il tasso di finanziamento di Bitcoin è sceso al 0,25% settimanale, considerato neutrale nei mercati in cui i trader sono solitamente rialzisti. Questo indica poca domanda per posizioni short, suggerendo che siano restii a scommettere su una diminuzione dei prezzi di Bitcoin al di sotto di $65.000.</p>
<p>Recentemente, il progetto meme su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> è diventato molto popolare e Slerf è una moneta meme su Solana che ha ricevuto ampia attenzione dalla comunità. Il 17 marzo, il creatore ha raccolto 535.000 token SOL per lanciare memecoin, ma ha accidentalmente bruciato Solana token del valore di $ 10,4 milioni nel tentativo di ripulire il portafoglio.</p>
<p>Ma questa mossa non ha azzerato Slerf a zero. Dopo che lo sviluppatore ha ammesso sulla piattaforma X che erano “davvero dispiaciuti per aver combinato un pasticcio” e “hanno distrutto LP e i token riservati per l’airdrop a causa di un errore di manipolazione, e i diritti di conio sono stati revocati”, il progetto è effettivamente “diventato virale” a causa di un errore; Influenzati dal sentimento della comunità, i prezzi sono schizzati alle stelle e hanno raggiunto anche un valore di mercato di 500 milioni di dollari in poche ore.</p>
<p>Anche con fattori di rischio, la prevendita delle monete memetiche di Solana continua ad attirare l’interesse delle persone. Ad esempio, la prevendita di un progetto chiamato ‘Are You Stupid’ ha accumulato 420,69 SOL (83.717 dollari) in una singola transazione. Al 16 marzo, gli utenti hanno 48 ore per inviare fondi all’indirizzo del portafoglio ‘areyoustupid.sol’ e gli investitori hanno il 99,99% di probabilità di non ricevere alcun ritorno, ma investono comunque.</p>
<p>La recente mania delle criptovalute meme è facile da confrontare con la schiuma del <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Prima era dell’emissione di token (ICO) nel 2017, quando diversi progetti cripto hanno raccolto milioni di dollari, ma molti non sono riusciti a consegnare.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20entra20nel20range20di20correzione20e20le20Altcoin20in20generale20scendono651774"><a name="Tendenze di mercato: BTC entra nel range di correzione e le Altcoin in generale scendono" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC entra nel range di correzione e le Altcoin in generale scendono</h2><p>La tendenza complessiva del mercato è debole, con BTC che entra in un intervallo di correzione e le Altcoins che in generale cadono significativamente. L’afflusso di ETF BTC è diminuito significativamente, mentre il fondo Grayscale Bitcoin Trust (GBTC) mantiene un enorme deflusso, arrivando anche a un nuovo massimo da quando sono stati approvati gli ETF spot.</p>
<p>Per quanto riguarda la macroeconomia, le azioni statunitensi sono leggermente aumentate e il mercato è generalmente preoccupato per la riunione sulla politica monetaria della Federal Reserve di questa settimana. Questa riunione potrebbe avere un impatto significativo sulla tendenza generale del mercato finanziario, quindi gli investitori sono cauti al riguardo.</p>
<h3 id="h3-Punti20Caldi20del20Mercato937157"><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>I token del concetto di Meme e Intelligenza Artificiale (AI) forti nella fase iniziale hanno portato il mercato a declinare, con un calo generale di oltre il 15%. La significativa diminuzione dei token NEAR è in linea con l’aspettativa del mercato che i progetti legati all’IA possano essere esagerati attraverso la Conferenza sull’Intelligenza Artificiale di Nvidia. Dopo la conferenza, i token NEAR hanno effettivamente mostrato un trend al ribasso.</p>
</li><li><p>I token SOL hanno subito un ritiro dopo aver superato i 200 dollari, portando a un calo generale dei token sulla catena Solana. Ieri pomeriggio, dopo il lancio del progetto sloth SLERF, è aumentato di più di dieci volte in breve tempo, attirando l’attenzione del mercato. Anche Gate.io ha lanciato SLERF per la prima volta ieri. Un altro popolare token Meme, BOME, ha avuto un forte aumento iniziale ed è ora entrato in una fase di correzione, scendendo del 66% rispetto al suo massimo storico.<br><img src="https://gimg2.gateimg.com/image/article/17108195101.png" alt=""><br>Sorgente: Gate.io</p>
</li></ol>
<h3 id="h3-Analisi20e20Prospettive811"><a name="Analisi e Prospettive" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi e Prospettive</h3><p>   In generale, il mercato è entrato in un periodo di adeguamento dopo la frenesia dei Meme, e il sentiment degli investitori è relativamente cauto. Con l’ajustamento di BTC, gli Altcoin potrebbero continuare ad essere influenzati, ed è necessario monitorare da vicino la tendenza di BTC. Inoltre, l’attenzione del mercato sulla riunione sulla politica monetaria della Federal Reserve è anche alta, il che potrebbe, in qualche modo, influenzare la tendenza del mercato delle criptovalute. Quando si scelgono gli obiettivi di investimento, gli investitori devono essere cauti e monitorare da vicino le tendenze di mercato.</p>
<h2 id="h2-Macro20Wall20Street20ha20chiuso20in20rialzo20lentusiasmo20del20mercato20per20le20azioni20tecnologiche20recupera20tensione20con20la20Federal20Reserve990818"><a name="Macro: Wall Street ha chiuso in rialzo, l’entusiasmo del mercato per le azioni tecnologiche recupera tensione con la Federal Reserve" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wall Street ha chiuso in rialzo, l’entusiasmo del mercato per le azioni tecnologiche recupera tensione con la Federal Reserve</h2><p>Sul fronte del mercato globale, i principali indici azionari di Wall Street hanno chiuso in rialzo lunedì, con grandi azioni di crescita come Alphabet e Tesla a supporto del rimbalzo dell’indice Nasdaq dominato dalla tecnologia. Nel frattempo, gli investitori attendono con ansia l’incontro della Federal Reserve di questa settimana.</p>
<p>Il Dow Jones Industrial Average (.DJI) è salito dello 0,20% a 38790,43 punti, mentre lo Standard &amp; Poor’s 500 Index (.SPX) è salito dello 0,63% a 5149,42 punti; Il Nasdaq Composite Index (.IXIC) ha concluso tre giorni consecutivi di calo, aumentando dello 0,82% a 16103,45 punti.</p>
<p>La Conferenza degli sviluppatori di intelligenza artificiale NVDA.O è iniziata e il CEO Huang Renxun ha dato il via alla conferenza annuale degli sviluppatori dell’azienda con una serie di annunci. Ha presentato l’ultimo chip di Nvidia, che è 30 volte più veloce del suo predecessore in specifici compiti. Il nuovo chip è diventato il focus e il prezzo delle azioni di Nvidia è salito dello 0,7%, ma ha chiuso molto al di sotto del massimo intraday.</p>
<p>La società madre di Google, Alphabet, sta trattando di integrare il motore AI Gemini di Google nell’iPhone, il che ha notevolmente stimolato il mercato. Ha sostenuto un aumento di quasi il 3% nel settore dei servizi di comunicazione, raggiungendo il livello più alto da settembre 2021 e guidando il 11 settori principali dell’indice S&amp;P 500.</p>
<p>Nel frattempo, il mercato si aspetta che la Federal Reserve mantenga la stabilità dei tassi di interesse mercoledì, con attenzione rivolta agli ultimi dati economici dei decisori politici, ai commenti del presidente Jerome Powell e alle previsioni dei tassi di interesse. Il rapporto sull’inflazione più forte del previsto della scorsa settimana ha portato i trader a ridurre le loro scommesse su un taglio dei tassi di interesse di quest’anno, con il mercato che si aspetta un taglio di 71 punti base quest’anno. All’inizio di quest’anno, i trader si aspettavano una riduzione dei prezzi di 150 punti base.</p>
<p>La Banca del Giappone diventa il centro del mercato asiatico. Il mercato azionario giapponese è sceso martedì insieme ai mercati regionali. Al contrario, lo yen giapponese è rimasto stabile ed è in procinto di tenere una cruciale riunione della Banca del Giappone, che potrebbe porre fine a otto anni di tassi di interesse negativi e introdurre la prima stretta di politica del paese dal 2007. Tutti i segnali indicano che la banca centrale sta abbandonando la sua politica monetaria ultra accomodante.</p>
<p>Per quanto riguarda le materie prime, il petrolio greggio statunitense è sceso dello 0,13% a 82,61 dollari al barile, mentre il petrolio Brent è sceso dello 0,09% a 86,81 dollari.<br>Martedì, i prezzi dell’oro sono rimasti stabili poiché gli investitori sono rimasti cauti in vista della riunione sulla politica monetaria della Federal Reserve di questa settimana, che potrebbe fornire ulteriori indizi sul momento dei possibili tagli dei tassi di interesse quest’anno. L’oro spot è salito dello 0,1% a 2.161,79 dollari l’oncia e i futures statunitensi sono saliti dello 0,1% a 2.165,30 dollari.</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 ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>