Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgY3JvbGxvIGRlbGxlIGF6aW9uaSB0ZWNub2xvZ2ljaGUgY2F1c2EgZmx1dHR1YXppb25pIGRpIG1lcmNhdG87IElsIG1lcmNhdG8gY3JpdHRvZ3JhZmljbyDDqCBnZW5lcmFsbWVudGUgaW4gcmliYXNzbywgbWEgbGUgbWVtZWNvaW4gTUVXLCBXSUYgZSBTb2xhbmEgc3Rhbm5vIGxldHRlcmFsbWV

2024-07-25, 03:25

<p><img src="https://gimg2.gateimg.com/image/article/17218778221_20.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20il20mercato20delle20criptovalute2020generalmente20in20calo20ma20le20criptovalute20MEW20WIF20e20Solana20stanno20volando20MonoSwap2020stato20hackerato20e20agli20utenti2020stato20consigliato20di20non20depositare20fondi20Fold20ha20pianificato20di20essere20quotata20su20NASDAQ20tramite20una20transazione20SPAC20da2036520milioni20di20dollari800824"><a name="Riepilogo giornaliero delle criptovalute: il mercato delle criptovalute è generalmente in calo, ma le criptovalute MEW, WIF e Solana stanno volando; MonoSwap è stato hackerato e agli utenti è stato consigliato di non depositare fondi; Fold ha pianificato di essere quotata su NASDAQ tramite una transazione SPAC da 365 milioni di dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: il mercato delle criptovalute è generalmente in calo, ma le criptovalute MEW, WIF e <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> stanno volando; MonoSwap è stato hackerato e agli utenti è stato consigliato di non depositare fondi; Fold ha pianificato di essere quotata su NASDAQ tramite una transazione SPAC da 365 milioni di dollari</h2><p>Prima, esaminiamo l’attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF. Secondo i dati di Farside Investor, il 24 luglio, il Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) ha registrato un deflusso di fondi di $26,2 milioni. Nel frattempo, il Fidelity Bitcoin Spot ETF (FBTC) ha ricevuto un afflusso di $1,4 milioni, il Bitwise Bitcoin Spot ETF (BITB) ha registrato un deflusso di $70,3 milioni, e l’ARK 21Shares Bitcoin Spot ETF (ARKB) ha registrato un deflusso di $3,3 milioni.</p>
<p>Flusso netto in entrata di $29,6 milioni per Bitwise <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Spot ETF (ETHW); flussi in entrata di $74,5 milioni per Fidelity Ethereum Spot ETF (FETH); flusso in entrata di $19,8 milioni per VanEck Ethereum spot ETF (ETHV); flusso netto in uscita di $326,9 milioni per Grayscale Ethereum spot ETF (ETHE).</p>
<p><strong>Con l’aumentare dell’attività online, MEW, WIF e <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Le memecoins volano</strong></p>
<p>La memecoin nell’ecosistema Solana ha raggiunto una crescita significativa negli ultimi sette giorni, superando il mercato delle criptovalute in generale. Secondo i dati di CoinGecko, il valore di mercato totale della memecoin sulla blockchain Solana è aumentato significativamente negli ultimi 7 giorni, raggiungendo i 9,2 miliardi di dollari al 24 luglio.</p>
<p>Cat in Dogs World (MEW) ha registrato il maggior aumento nella scorsa settimana, salendo dell’82% e dell’1.4% nelle ultime 24 ore. Segue da vicino Gigachad (GIGA), che è salito del 45.5% negli ultimi 7 giorni e del 9% nelle ultime 24 ore, raggiungendo una crescita a due cifre.</p>
<p>Calcolato in base al valore di mercato, Dogwifhat (WIF), il più grande token meme basato su Solana, ha registrato un aumento del 1,8% nello stesso giorno e un aumento del 21,5% entro una settimana, raggiungendo un valore di mercato di $2,54 miliardi. È interessante notare che WIF rappresenta quasi un terzo della capitalizzazione di mercato totale dei Memecoin di Solana. Le prestazioni rialziste dei Solana Memecoins riflettono un sentimento più ampio tra gli investitori nei confronti del settore. Secondo un recente rapporto di CoinGecko, questa classe di asset è diventata uno dei temi più caldi del secondo trimestre del 2024.</p>
<p>Secondo i dati di DefiLlama, il volume di scambi di Solana è salito da 603,8 milioni di dollari il 29 giugno a 2,54 miliardi di dollari il 19 luglio. Il volume di transazioni più alto nella storia di questa blockchain è stato fissato il 15 marzo a 3,8 miliardi di dollari. Il numero di indirizzi attivi sulla rete Solana è aumentato nettamente nelle ultime due settimane. Il numero di indirizzi attivi il 23 luglio ha superato i 2 milioni, il che è il 72% in più rispetto all’1,45 milioni del 10 luglio.</p>
<p><strong>MonoSwap è stato hackerato e agli utenti è stato consigliato di non depositare fondi</strong></p>
<p>Il 24 luglio 2024, la piattaforma di scambio decentralizzata e di staking MonoSwap ha annunciato di essere stata attaccata da hacker malintenzionati e ha avvertito gli utenti di non fare stake o aggiungere fondi aggiuntivi in questo momento. MonoSwap sta indagando su questo incidente. Nell’annuncio, MonoSwap avverte gli utenti di ritirare immediatamente i fondi dalla piattaforma per evitare perdite e di non interagire con <a href="/price/link-ln" target="_blank" class="blog_inner_link">link</a> malintenzionati identificati dal protocollo nei post dei social media.</p>
<p>Secondo la piattaforma, il 23 luglio 2024, uno dei suoi sviluppatori ha installato accidentalmente un’applicazione di phishing maligna ed è stato attirato da truffatori che fingevano di essere venture capitalist. Durante la chiamata, il truffatore ha installato un software maligno sul computer dello sviluppatore, che aveva accesso a tutti i portafogli e contratti sulla piattaforma. Ciò consente agli hacker di estrarre la maggior parte della liquidità di staking sulla piattaforma.</p>
<p>Dopo che il co-fondatore di CoinGecko ha lanciato un avvertimento, ci sono stati molti incidenti di alto profilo di attacchi informatici ed exploit di vulnerabilità. L’investigatore Onchain ZackXBT ha recentemente emesso un avviso al <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a> Sito web finanziario, che ha reindirizzato gli utenti a pagine di phishing. Il team di <a href="/price/compound-comp" target="_blank" class="blog_inner_link">Compound</a> Finance ha successivamente risolto questo problema.</p>
<p><strong>L’applicazione di ricompensa Bitcoin Fold ha pianificato di andare pubblica su NASDAQ attraverso lo scambio SPAC da $365 milioni</strong></p>
<p>L’applicazione di ricompensa Bitcoin Fold prevede di essere quotata su NASDAQ attraverso una fusione con la Special Purpose Acquisition Corporation (SPAC) Emerald Acquisition Corp. (EMLD). Dopo il completamento della transazione, ci saranno oltre 1.000 Bitcoin (67 milioni di dollari) nel bilancio dell’entità.</p>
<p>Fold, con sede a New York, ha lanciato una carta di debito cashback che sostituisce le tradizionali ricompense offrendo ricompense in Bitcoin. Secondo un annuncio di mercoledì, la carta di Fold ha elaborato oltre 2 miliardi di dollari di volume di transazioni e ha emesso ricompense per un valore di oltre 45 milioni di dollari.</p>
<p>Questa transazione ha ricevuto l’approvazione unanime dei consigli di amministrazione di entrambe le società, con una valutazione patrimoniale pre-transazione di $365 milioni. Dopo la transazione, ci saranno oltre 1.000 Bitcoin ($67 milioni) nel bilancio dell’entità. Fold non ha ancora reso noto il tempo previsto per il completamento della fusione e il suo codice di negoziazione su NASDAQ.</p>
<h2 id="h2-Tendenze20di20mercato20Il20mercato20complessivo2020diminuito20ma20il20sentiment20di20mercato20rimane20ottimista707845"><a name="Tendenze di mercato: Il mercato complessivo è diminuito, ma il sentiment di mercato rimane ottimista" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: Il mercato complessivo è diminuito, ma il sentiment di mercato rimane ottimista</h2><p>Il BTC è sceso sotto i $64.500 e ha attraversato il mezzo delle bande settimanali di Bollinger. Se il BTC può riprendersi e tornare sopra il mezzo delle bande settimanali di Bollinger questa settimana, ci si aspetta comunque che il mercato sia rialzista in futuro. Tuttavia, se il grafico settimanale chiude al di sotto del mezzo delle bande di Bollinger, potrebbe continuare a fluttuare al ribasso.</p>
<p>ETH è sceso sotto i $3.200. L’ETF Ethereum di Grayscale continua a registrare grandi deflussi. In precedenza, l’ETF Ethereum di Grayscale era stato a uno sconto negativo di circa -40% per molto tempo, e gli acquirenti hanno ottenuto maggiori profitti vendendo, causando una enorme pressione sul mercato.</p>
<p>Le altcoin sono generalmente diminuite e il settore dei Meme ha anche registrato un calo. A questo punto, puoi considerare di acquistare la valuta Meme precedentemente forte a lotti, il che potrebbe generare ulteriori rendimenti in futuro.</p>
<p>Sentimento di mercato: oggi l’indice AHR999 è 0,87, il che indica che il prezzo attuale del BTC è adatto per investimenti a lungo termine. L’indice Paura e Avidità è 68, e il sentimento del mercato è stato in uno stato avido per quattro giorni consecutivi. Nonostante la caduta generale del mercato, il sentimento del mercato non è caduto nel panico.</p>
<h3 id="h3-Macroeconomia651859"><a name="Macroeconomia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia</h3><p>Performance delle azioni statunitensi: i tre principali indici di borsa statunitensi sono tutti diminuiti, con i giganti dell’IA come Nvidia e Broadcom che guidano il calo e l’indice delle sette grandi borse statunitensi che scende del 5,9%.</p>
<p>Mercato obbligazionario: Il rendimento del titolo del tesoro a 30 anni degli Stati Uniti ha superato il rendimento del titolo del tesoro a 5 anni, il margine più ampio da maggio 2023.</p>
<p>Aspettativa di politica: Dopo il ritiro di Biden dalle elezioni, l’aspettativa di un taglio dei tassi d’interesse della Federal Reserve a settembre è diminuita e il mercato si trova in uno stato di instabilità macroeconomica.</p>
<h3 id="h3-Hotspot20di20mercato723687"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h3><p><strong>Ecosistema Solana:</strong><br>Performance SOL/ETH: SOL/ETH continua a rafforzarsi, con SOL che ha superato i 180 dollari ieri. Ci si aspetta che questa forte performance continuerà nel futuro mercato.</p>
<p>Le memecoin on-chain: le memecoin sulla catena Solana hanno avuto una buona performance in questo periodo di trend al rialzo, con le cat coin POPCAT, MEW, ecc. che hanno superato i massimi storici, e Zhaocai Cat Meme Coin MANEKI che ha registrato un aumento di oltre il 100% dal minimo.</p>
<h3 id="h3-Conclusione254159"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h3><p>Il mercato cripto attuale presenta una situazione complessa e volatile, con le principali criptovalute come BTC ed ETH che subiscono una pressione al ribasso, ma il sentiment di mercato rimane relativamente ottimista. In un trend ribassista, gli utenti dovrebbero dare priorità all’acquisto di token solidi sulla strong public chain in lotti uno per uno. Considerando l’incertezza dell’economia macro e i cambiamenti nei punti caldi del mercato, gli investitori dovrebbero rimanere cauti, diversificare i rischi e dare priorità agli investimenti in asset solidi.</p>
<h2 id="h2-Macro20Il20brusco20calo20delle20azioni20tecnologiche20ha20influenzato20il20mercato20azionario20con20sia20Wall20Street20che20i20mercati20asiatici20che20subiscono20pesanti20perdite483572"><a name="Macro: Il brusco calo delle azioni tecnologiche ha influenzato il mercato azionario, con sia Wall Street che i mercati asiatici che subiscono pesanti perdite" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Il brusco calo delle azioni tecnologiche ha influenzato il mercato azionario, con sia Wall Street che i mercati asiatici che subiscono pesanti perdite</h2><p>Il 24 luglio, gli indici S&amp;P 500 e Nasdaq sono scesi ai minimi delle ultime settimane alla chiusura di mercoledì, poiché le prestazioni inferiori alle aspettative di Alphabet e Tesla hanno indebolito la fiducia degli investitori nelle azioni a grande capitalizzazione.</p>
<p>Gli investitori stavano aspettando che la prima società tra le “Big Seven” annunciasse la sua performance trimestrale per determinare se le valutazioni elevate sono ragionevoli. La performance di queste sette società ha un impatto significativo sul mercato ed è destinata ad avere una reazione a catena ad ampio raggio sul mercato complessivo.</p>
<p>Le principali performance degli indici sono le seguenti: l’indice Dow Jones è sceso dell’1,25%, l’indice S&amp;P è sceso del 2,31% e l’indice Nasdaq è sceso del 3,64%.</p>
<p>Giovedì mattina, 25 luglio, i mercati azionari asiatici sono stati duramente colpiti dalle prestazioni delle azioni tecnologiche e gli investitori si sono rivolti a asset a basso rischio, tra cui obbligazioni a breve termine, yen giapponese e franco svizzero.</p>
<p>L’indice azionario più utilizzato del MSCI Asia Pacific è sceso dello 0,7%, l’indice Nikkei del Giappone è precipitato del 2,9% e l’indice KOSPI della Corea del Sud è sceso del 2%. Il mercato di Taiwan continua a chiudere a causa dell’impatto del tifone. Le azioni blue chip cinesi hanno ridotto il loro calo precedente dello 0,1%, mentre l’Indice Composito di Shanghai è sceso dello 0,3%, toccando un minimo di cinque mesi. L’Hang Seng Index di Hong Kong è sceso dello 0,6%, nonostante le ultime misure di allentamento di Pechino, che non hanno fornito un sufficiente supporto.</p>
<p>L’indice del panico di Wall Street è salito a un massimo di tre mesi. Gli investitori stanno cercando denaro sicuro e debiti a breve termine altamente liquidi, con i rendimenti dei bond statunitensi a due anni che sono scesi ai loro livelli più bassi da quasi sei mesi mercoledì.</p>
<p>Lo yen giapponese, come valuta rifugio sicura, è salito dell’0,6%, raggiungendo il suo livello più alto da due mesi e mezzo. Durante la notte, lo yen giapponese è salito dell’1,1% e il suo slancio al rialzo rimane forte in vista dell’incontro della banca centrale di domenica prossima, dove i decisori discuteranno se aumentare i tassi di interesse. Anche il franco svizzero è salito dell’0,7% durante la notte.</p>
<p>La Banca Popolare della Cina ha abbassato inaspettatamente i tassi di interesse a lungo termine e aumentato le recenti misure di stimolo, ma il mercato azionario cinese non ha ricevuto molto sostegno.</p>
<p>Il calo del mercato azionario ha portato gli investitori ad aumentare le scommesse sui tagli dei tassi di interesse globali, con i mercati futures che mostrano una probabilità del 100% che la Federal Reserve tagli i tassi di interesse a settembre. L’impennata della volatilità di mercato ha portato a una significativa riduzione del trading di arbitraggio, causando un ulteriore calo del dollaro statunitense dello 0,6% rispetto allo yen giapponese giovedì a 152,85.</p>
<p>Di fronte al crollo dominato dalle azioni di grande capitalizzazione, il mercato ha rivalutato le prospettive di profitto dell’altamente pubblicizzato intelligenza artificiale e dei sette giganti del settore. Il brusco calo di Alphabet e Tesla ha innescato il crollo di Wall Street. Inoltre, le preoccupazioni per la Cina e la crescita economica globale hanno esercitato una pressione enorme sulle valute legate alle materie prime, e la propensione al rischio nei mercati cinese e giapponese continuerà.</p>
<p>Per quanto riguarda le materie prime, a causa delle preoccupazioni per il rallentamento economico cinese che sopprime la domanda, i prezzi del petrolio sono leggermente diminuiti e rimasti vicini al minimo delle sei settimane. I futures del greggio Brent sono scesi dello 0,4% a $81,81 al barile, mentre i futures del West Texas Intermediate (WTI) degli Stati Uniti sono anche scesi dello 0,3% a $77,33 al barile.</p>
<p>Il oro è sceso dello 0,9% a $2.375,92 per oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Glassa</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. Il repost dell'articolo sarà consentito a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa delle violazioni del copyright.<br></div><p></p><br></div></div></div></div>