RGFpbHkgTmV3cyB8IElsIHRyYWRpbmcgZGkgQ3J5cHRvIFZDIGhhIHJhZ2dpdW50byB1biBtYXNzaW1vIGRpIHVuIGFubm8gYSBtYXJ6bzsgSW1tdXRhYmxlIGhhIGxhbmNpYXRvIHVuIHByb2dyYW1tYSBkaSByaWNvbXBlbnNlIHBlciBnaW9jaGkgZGEgNTBNOyBXTEQgY29sbGFib3JlcsOgIGNvbiBQYXlQYWwgT3BlbkFJ

2024-04-26, 03:42

<p><img src="https://gimg2.gateimg.com/image/article/171410289326.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Il20numero20di20transazioni20VC20crypto20ha20raggiunto20un20nuovo20massimo20annuale20Immutable20lancia20un20programma20di20premi20di205020milioni20di20giochi20Worldcoin20collaborer20con20PayPal20OpenAI840130"><a name="Crypto Daily Digest: Il numero di transazioni VC crypto ha raggiunto un nuovo massimo annuale; Immutable lancia un programma di premi di 50 milioni di giochi; Worldcoin collaborerà con PayPal OpenAI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Il numero di transazioni VC crypto ha raggiunto un nuovo massimo annuale; Immutable lancia un programma di premi di 50 milioni di giochi; Worldcoin collaborerà con PayPal OpenAI</h2><p>Prima di tutto, esaminiamo le 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 25 aprile, i fondi ETF spot di Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> (GBTC) hanno avuto un deflusso di denaro pari a 139,4 milioni di dollari. Nel frattempo, i fondi ETF spot di Bitcoin di Fidelity (FBTC) hanno registrato un deflusso di 22,6 milioni di dollari, i fondi ETF spot di Bitcoin di Bitwise (BITB) hanno registrato un deflusso di 6 milioni di dollari e i fondi ETF spot di Bitcoin di ARK 21Shares (ARKB) hanno registrato un deflusso di 31,3 milioni di dollari. Oggi c’è un significativo deflusso di fondi ETF spot di Bitcoin.</p>
<p>Secondo un rapporto di ricerca di CoinTelegraph, nonostante le recenti fluttuazioni e le contrazioni del mercato, le criptovalute come Bitcoin stanno vivendo un periodo di raffreddamento. Tuttavia, nel marzo e nell’aprile 2024, il mercato del capitale di rischio ha continuato a riprendersi. A marzo sono state completate 161 transazioni, raggiungendo un record di 12 mesi. Gli investimenti totali hanno superato 1 miliardo di dollari, con un aumento del 52% rispetto al mese precedente. Anche se aprile non è ancora finito, sono state registrate 90 transazioni che hanno attratto oltre 820 milioni di dollari di investimenti. A marzo, il numero di transazioni ha raggiunto il suo livello più alto in 12 mesi.</p>
<p>L’afflusso di nuovo capitale di rischio ha anche stimolato le attività degli sviluppatori, specialmente nei settori emergenti come l’intelligenza artificiale e le soluzioni di infrastruttura L1/L2/L3. Il settore dell’infrastruttura è il più attraente per gli investitori, con un investimento totale di oltre $1.2 miliardi in marzo e aprile.</p>
<p>Diversi fondi annunciati o lanciati nei mesi scorsi hanno stimolato il recupero del mercato del capitale di rischio criptato. Oltre al noto Hack VC e Immune x <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> oltre a fondi, sono stati anche rilasciati diversi nuovi fondi. Il più sorprendente tra questi è Paradigm, che ha annunciato una raccolta di fondi di 850 milioni di dollari per reinvestire i fondi nel settore del capitale di rischio criptato.</p>
<p>Anche l’industria del GameFi ha mostrato segni di ripresa, ricevendo il supporto di a16z. L’azienda prevede di investire 30 milioni di dollari in startup di giochi tecnologici, concentrandosi su intelligenza artificiale, realtà virtuale/aumentata e tecnologia Web3.</p>
<p>Immutable ha annunciato il lancio del “più grande programma di missioni e premi di gioco <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> mai realizzato”, offrendo ai giocatori 50 milioni di dollari in token di ricompensa. L’azienda ha dichiarato che l’ecosistema Immutable ha oltre 270 giochi in fase di sviluppo, tra cui progetti molto attesi come Illuvium e MetalCore.</p>
<p>Secondo l’annuncio dell’azienda, i giocatori possono immediatamente ricevere ricompense esplorando missioni, giocando e possedendo preferiti su Immutable. Con la continua maturità dei giochi web3 e il rilascio di più giochi con budget più grandi al pubblico, sembra che Immutable voglia attirare più giocatori attraverso programmi di ricompense.</p>
<p>Bloomberg ha riportato che lo sviluppatore di Worldcoin, Tools for Humanity, è interessato a collaborare con il gigante dei pagamenti PayPal e l’azienda di intelligenza artificiale OpenAI. Tuttavia, i dettagli della partnership sono ancora poco chiari e non sono ancora emersi piani specifici.</p>
<p>Il concetto di Worldcoin consiste nel verificare l’identità dell’utente scansionando le informazioni dell’iride e, in cambio, l’utente può ottenere il cripto WLD. Sam Altman, presidente e co-fondatore di Tools for Humanity, è anche co-presidente di OpenAI, un famoso sviluppatore di Generative AI ChatGPT.</p>
<h2 id="h2-Tendenze20di20mercato20il20mercato2020debole20e20volatile20e20il20settore20dei20Meme2020la20storia20principale20di20questa20fase914668"><a name="Tendenze di mercato: il mercato è debole e volatile, e il settore dei Meme è la storia principale di questa fase" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il mercato è debole e volatile, e il settore dei Meme è la storia principale di questa fase</h2><p>Bitcoin (BTC) è sceso sotto i 63.000 dollari ieri sera e il mercato crittografico nel complesso ha mostrato un trend debole e volatile. Nonostante le scarse prestazioni complessive del mercato, il settore Meme rimane il principale focus di questa fase di trading, dimostrando una relativa forte resilienza.</p>
<p>Sul fronte macroeconomico, il mercato azionario statunitense è sceso. I dati economici del PIL per il primo trimestre degli Stati Uniti indicano che l’economia è caduta in stagnazione, mentre l’inflazione è aumentata per tre mesi consecutivi. Questi fattori hanno inflitto un duro colpo alle aspettative di mercato per i tagli dei tassi di interesse, aggravando l’incertezza degli investitori e la volatilità del mercato.</p>
<h3 id="h3-Hotspot20del20mercato708719"><a name="Hotspot del mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot del mercato:</h3><p>Settore dei meme: I token come BONK e PEPE nel settore dei meme hanno mostrato una forte performance nonostante la diffusa diminuzione del mercato. I token dei meme sono diventati il centro dell’attenzione degli investitori in questa fase di mercato grazie al loro meccanismo di emissione equo, una buona struttura di chip e nessuna precedente pressione da parte del capitale di rischio. L’unicità di questo tipo di token e il supporto della comunità gli hanno garantito una stabile performance di mercato.</p>
<p>L’ascesa dei Rune Dogs: Come membro della serie Rune, i Dogs hanno un valore di mercato di 500 milioni di dollari e sono stati lanciati su Gate.io. L’ascesa di DOG potrebbe essere guidata dalla sua posizione unica e funzionalità nel mercato, oltre alla crescente disponibilità delle piattaforme di trading.</p>
<p>Sebbene il mercato complessivo sia volatile, soprattutto in un contesto macroeconomico sfavorevole, il settore dei Meme mostra ancora una forte performance di mercato e potenziale di investimento. Gli investitori dovrebbero continuare a monitorare il settore dei Meme e seguire da vicino le variazioni della situazione economica globale e della politica monetaria per apportare tempestivamente adeguamenti e decisioni. Nel contesto attuale del mercato, mantenere una strategia di investimento flessibile e prudente è particolarmente importante.</p>
<h2 id="h2-Macro20Il20mercato20globale20continua20ad20essere20cauto20con20alti20e20bassi20misti20la20crisi20dello20yen20giapponese20cerca20una20risposta20dalla20Banca20del20Giappone742869"><a name="Macro: Il mercato globale continua ad essere cauto, con alti e bassi misti; la crisi dello yen giapponese cerca una risposta dalla Banca del Giappone" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Il mercato globale continua ad essere cauto, con alti e bassi misti; la crisi dello yen giapponese cerca una risposta dalla Banca del Giappone</h2><p>La borsa di Wall Street ha chiuso in ribasso giovedì a seguito dei dati che mostrano una crescita economica degli Stati Uniti più lenta del previsto e un’inflazione persistente, unita a una deludente performance che ha portato a una vendita massiccia delle azioni a grande capitalizzazione.</p>
<p>Le prestazioni di Meta tra i giganti tecnologici sono state insoddisfacenti, ma i risultati trimestrali di Alphabet (GOOGL.O) e Microsoft hanno superato le aspettative di Wall Street, facendo salire i futures degli indici azionari statunitensi. I futures del Nasdaq sono saliti di oltre l’1%, mentre i futures dell’indice S&amp;P 500 sono saliti dello 0,7%.</p>
<p>Secondo i dati della Borsa di Londra, il mercato monetario si aspetta che la Federal Reserve riduca i tassi di interesse di circa 36 punti base quest’anno, rispetto a circa 150 punti base all’inizio dell’anno.</p>
<p>I mercati azionari asiatici sono saliti con cautela venerdì, con l’indice Nikkei del Giappone leggermente in rialzo dello 0,02%. L’indice azionario MSCI Asia Pacific è salito dello 0,27%, mentre l’indice azionario australiano S&amp;P/ASX 200 è sceso di più dell’1%. L’indice Hang Seng di Hong Kong è salito dello 0,3%.</p>
<p>L’attenzione dell’Asia è sulla decisione sui tassi di interesse presa dalla Banca del Giappone al termine della sua riunione di politica monetaria di due giorni, così come sulla successiva conferenza stampa del governatore Ichio Ueda. Prima che i risultati fossero annunciati, il tasso di cambio dello yen nei confronti del dollaro era cambiato a malapena, rimanendo intorno al minimo di 34 anni di 155,62 yen, mentre il rendimento del bond del tesoro giapponese decennale è salito al massimo di cinque mesi del 0,93%.</p>
<p>A causa della chiara comprensione del mercato che gli Stati Uniti sono probabili che tagli i tassi di interesse per un po’ di tempo, i titoli di stato giapponesi sono in difficoltà prima che la decisione di politica diventi attentamente monitorata dalla banca centrale. Ciò che complica la situazione per la Banca del Giappone è che i dati di venerdì hanno mostrato che il rallentamento dell’inflazione di base a Tokyo in aprile ha superato le aspettative ed è stato inferiore all’obiettivo della Banca del 2%.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono aumentati nelle prime contrattazioni di venerdì poiché gli investitori hanno valutato le dichiarazioni del segretario al Tesoro degli Stati Uniti, affermando che l’economia potrebbe essere più forte di quanto indicato dai dati del primo trimestre, uniti alle preoccupazioni per l’offerta causate dai conflitti in corso in Medio Oriente. I futures del petrolio Brent sono saliti di 34 centesimi, o 0,38%, a 89,35 dollari al barile. I futures del petrolio greggio West Texas Intermediate negli Stati Uniti sono saliti di 33 centesimi, o 0,39%, a 83,90 dollari al barile.</p>
<p>L’oro è sceso dello 0,08% a $2.329,50 l’oncia. La recente crescita complessiva dei prezzi dell’oro ha aiutato Newmont (il più grande produttore di oro al mondo) a ottenere profitti, con il suo profitto del primo trimestre che ha superato le aspettative e il prezzo delle sue azioni che è aumentato del 12%.</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. La ripubblicazione dell'articolo sarà consentita a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>