Tm90aXppZSBxdW90aWRpYW5lIHwgU09MIHN1cGVyYSBpIDE4MCBkb2xsYXJpOyBGb25kYXppb25lIEFyYml0cnVtIGlzdGl0dWlzY2UgdW4gZm9uZG8gZGkgZ2lvY28gZGEgNDAwIG1pbGlvbmkgZGkgZG9sbGFyaTsgUHJvZG90dGkgZ2xvYmFsaSBkaSBpbnZlc3RpbWVudG8gaW4gY3JpcHRvdmFsdXRlIHN1cGVyYW5vIGkgMTAwIG1pbGl

2024-03-15, 03:36

<p><img src="https://gimg2.gateimg.com/image/article/17104737661_10.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20I20prezzi20di20Sol20hanno20superato20i2018020e20la20capitalizzazione20di20mercato20ha20raggiunto20un20massimo20storico20La20Fondazione20Arbitrum20ha20istituito20un20fondo20di2040020milioni20per20il20settore20dei20videogiochi20La20dimensione20dei20prodotti20di20investimento20crypto20globali20ha20superato20per20la20prima20volta20i2010020miliardi795270"><a name="Crypto Daily Digest: I prezzi di Sol hanno superato i $180 e la capitalizzazione di mercato ha raggiunto un massimo storico; La Fondazione Arbitrum ha istituito un fondo di $400 milioni per il settore dei videogiochi; La dimensione dei prodotti di investimento crypto globali ha superato per la prima volta i $100 miliardi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: I prezzi di Sol hanno superato i $180 e la capitalizzazione di mercato ha raggiunto un massimo storico; La Fondazione Arbitrum ha istituito un fondo di $400 milioni per il settore dei videogiochi; La dimensione dei prodotti di investimento crypto globali ha superato per la prima volta i $100 miliardi</h2><p>Prima di tutto, esaminiamo l’attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Secondo i dati dell’investitore Farside, il 14 marzo gli outflow di Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot (GBTC) sono stati pari a $ 257,2 milioni; nel frattempo, gli inflow di Fidelity Bitcoin spot ETF (FBTC) sono stati di $ 13,7 milioni e quelli di ARK 21Shares Bitcoin spot ETF (ARKB) di $ 3,5 milioni.</p>
<p>Secondo CoinShares, aziende di gestione patrimoniale come BlackRock, Fidelity, ProShares e 21Shares hanno gestito oltre 100 miliardi di dollari in prodotti di investimento criptovalutari a livello globale.</p>
<p>Nelle ultime settimane, gli afflussi globali di fondi cripto hanno raggiunto un massimo storico, uniti agli aumenti di prezzo recenti nel mercato cripto, ciò ha portato la gestione patrimoniale a raggiungere un massimo storico. James Butterfill, direttore delle ricerche presso CoinShares, ha scritto: ‘Per la prima volta, l’ammontare totale dei prodotti negoziati in borsa di asset digitali ha superato la soglia dei 100 miliardi di dollari’.</p>
<p>Il mercato delle criptovalute è leggermente fiacco oggi poiché il recente rapporto sull’Indice dei prezzi alla produzione (PPI) rilasciato dal Dipartimento del lavoro degli Stati Uniti ha influenzato il sentimento degli investitori, misurando la variazione media dei prezzi di beni e servizi per i produttori domestici. L’IPP è aumentato dello 0,6% da gennaio a febbraio, riducendo la probabilità che la Federal Reserve riduca i tassi di interesse il 20 marzo.</p>
<p>Il 13 marzo, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L’aggiornamento di Dencun ha ridotto le commissioni di Gas, e gli analisti hanno osservato che il trading sulla piattaforma di scambio decentralizzata Layer 2 di Base è ora molto più economico rispetto al trading su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>. Sorprendentemente, il 14 marzo, le prestazioni di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> sono state solide, superando i 180 dollari; la capitalizzazione di mercato di Solana ha raggiunto un massimo storico di 81,1 miliardi di dollari.</p>
<p>Ciò è principalmente dovuto ai recenti meme coins e airdrop attraenti, come Dogwifhat (WIF), Bonk e Jupiter (JUP). Nonostante le preoccupazioni per la centralità o la stabilità rispetto ad Ethereum, le attività sulla rete Solana continuano a crescere. I token SPL hanno senza dubbio causato una sensazione ed sono stati elencati più volte su importanti exchange centralizzati.</p>
<p>I dati più recenti degli ultimi sette giorni mostrano che il valore totale bloccato (TVL) di Solana è aumentato del 13%, mentre il numero di DApp è aumentato del 24%. D’altra parte, il TVL della principale blockchain, Ethereum, è leggermente diminuito, ma il numero di DApp è aumentato dell’11%. Per quanto riguarda i numeri assoluti del TVL, Solana è ancora in ritardo rispetto a <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain e Arbitrum, con depositi di $3.5 miliardi e $2.6 miliardi, rispettivamente.</p>
<p>Nell’ecosistema Solana, la casa di cambio cripto Drift prevede di lanciare un Launchpad per i nuovi token e la co-fondatrice di Drift, Cindy Leow, suggerisce che il Launchpad potrebbe aiutare a creare una migliore scoperta dei prezzi. Il primo token online sarà il prossimo W di Wormhole.</p>
<p>La Fondazione Arbitrum ha annunciato piani per investire 200 milioni di ARB (circa 400 milioni di dollari) entro due anni per promuovere i suoi progetti di giochi blockchain. La fondazione richiederà al suo DAO di approvare il piano, che investirà la maggior parte dei fondi per accelerare lo sviluppo del suo ecosistema di giochi fornendo sovvenzioni a editori e sviluppatori.</p>
<p>La nuova proposta suggerisce di allocare la grande maggioranza dei fondi (160 milioni di ARB) per incentivare editori e sviluppatori a creare nuovi giochi su Arbitrum. Ulteriori 40 milioni di ARB supporteranno piani infrastrutturali, come la creazione di strumenti per supportare i giochi all’interno di Arbitrum.</p>
<p>La Fondazione Arbitrum ha dichiarato nel suo post: “L’obiettivo generale del programma Gaming Catalyst è quello di portare sviluppatori di talento e aiutare gli sviluppatori ad accelerare i loro giochi durante la fase del ciclo di vita.”</p>
<h2 id="h2-Tendenze20di20mercato20SOL20guida20il20mercato20attraverso20una20performance20attiva20nel20settore20dellIA826063"><a name="Tendenze di mercato: SOL guida il mercato attraverso una performance attiva nel settore dell’IA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: SOL guida il mercato attraverso una performance attiva nel settore dell’IA</h2><p>Bitcoin (BTC) ha superato la resistenza di $68.000 nelle prime ore del mattino ma è tornato sopra i $72.000. Il trend del BTC è relativamente lento, e sembra che stia coltivando l’abitudine degli utenti di inserire aghi per acquistare in fondo. Allo stesso tempo, le Altcoin sono generalmente diminuite, indicando un’atmosfera di mercato complessivamente debole.</p>
<p>In termini di macroeconomia, il mercato azionario statunitense è diminuito e i dati sull’inflazione PPI di febbraio sono stati più alti del previsto, il che potrebbe avere un impatto negativo sui tagli dei tassi di interesse.</p>
<h3 id="h3-Punti20caldi20di20mercato361403"><a name="Punti caldi di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi di mercato</h3><ol>
<li><p>SOL continua a salire: l’ecosistema Solana continua a vivere un’impennata collettiva, con aumenti significativi nei token on-chain.</p>
</li><li><p>Il settore layer2 mostra una tendenza al ribasso: La diminuzione collettiva dei token nei settori Layer2, come ARB, STRK, OP, ecc., potrebbe essere correlata all’aggiornamento Cancun inferiore alle aspettative.</p>
</li><li><p>Il settore dell’IA è attivo: Token come LPT, NEAR, ARKM, FET, ecc., sono aumentati nel settore, e il mercato sta speculando che ChatGPT verrà rilasciato per una settimana e diventerà un argomento caldo a breve termine. L’attività del settore dell’IA dimostra l’attenzione continua degli investitori e la ricerca dei campi tecnologici emergenti.</p>
</li></ol>
<p>Il mercato odierno mostra le caratteristiche dell’ecosistema Solana che guida il mercato e il settore AI attivo. Gli investitori dovrebbero monitorare attentamente le tendenze di mercato, regolare prontamente le strategie di investimento e cogliere le opportunità di investimento. Allo stesso tempo, si dovrebbe prestare attenzione anche alla tendenza complessiva del mercato e all’impatto dei dati macroeconomici sul mercato e fare una buona gestione del rischio e diversificazione degli asset.</p>
<h2 id="h2-Macro20I20dati20sullinflazione20negli20Stati20Uniti20stanno20aumentando20Limpatto20della20geopolitica20sui20futuri20prezzi20del20petrolio20Il20declino20delloro581404"><a name="Macro: I dati sull’inflazione negli Stati Uniti stanno aumentando; L’impatto della geopolitica sui futuri prezzi del petrolio; Il declino dell’oro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I dati sull’inflazione negli Stati Uniti stanno aumentando; L’impatto della geopolitica sui futuri prezzi del petrolio; Il declino dell’oro</h2><p>L’imprevisto aumento dei prezzi alla produzione nei dati notturni degli Stati Uniti ha intensificato l’interpretazione dell’inflazione dei consumatori all’inizio di questa settimana. Secondo l’applicazione della probabilità dei tassi di interesse di LSEG, ci si aspetta che il mercato dei futures riduca la probabilità di un’azione di politica monetaria a giugno da circa il 67% a tarda serata di mercoledì al 60%. Per il taglio dei tassi di interesse nel 2024, il numero previsto di tagli dei tassi circa due settimane fa era di 3-4, e ora il mercato si aspetta che il numero di tagli dei tassi sarà inferiore a 3.</p>
<p>Dopo che l’indice Standard &amp; Poor’s 500 (.SPX) è sceso dello 0,29%, i futures degli indici azionari statunitensi sono leggermente diminuiti a causa del significativo sell-off delle azioni del settore dei chip, che ha influenzato il mercato asiatico e ha messo sotto pressione gli indici azionari della regione. A seguito del calo degli stock tecnologici durante la notte che ha portato a una diminuzione di Wall Street, i mercati azionari asiatici sono crollati venerdì. Allo stesso tempo, l’inflazione negli Stati Uniti superiore alle aspettative ha frenato le scommesse sul momento e sulla frequenza dei tagli dei tassi di interesse della Federal Reserve.</p>
<p>Dopo il suo più grande aumento in tre mesi, il rendimento dei titoli obbligazionari di riferimento degli Stati Uniti è rimasto intorno al 4,3% giovedì per la prima volta questo mese. Il tasso di cambio del dollaro statunitense rispetto a un paniere di valute principali è salito ai livelli più alti dal 5 marzo.</p>
<p>L’indice Hang Seng (.HSI) di Hong Kong è sceso di oltre l’1%, così come il Kospi (.KS11) in Corea del Sud; l’indice Nikkei del Giappone (.N225) è sceso dello 0,3%.</p>
<p>La Banca del Giappone continua a mostrare segni di ritiro dalle sue misure di stimolo ultra-libero nella sua riunione di politica di due giorni, che si concluderà martedì prossimo. Il governo giapponese sembra sostenere un cambio di politica, con il Ministro delle Finanze Toshio Suzuki che ha dichiarato venerdì che l’economia non è più intrappolata nella deflazione. Tuttavia, all’inizio di questa settimana, era troppo presto per annunciare la fine del declino dei prezzi a lungo termine del paese.</p>
<p>La geopolitica potrebbe influenzare i futuri prezzi del petrolio. A causa della interruzione delle spedizioni nel Mar Rosso causata dagli Houthi, l’Agenzia Internazionale dell’Energia ha aumentato la sua previsione sulla crescita della domanda di petrolio nel 2024 per la quarta volta da novembre, giovedì. L’IEA ha dichiarato nel suo ultimo rapporto che la domanda globale di petrolio aumenterà di 1,3 milioni di barili al giorno nel 2024, un aumento di 110.000 barili al giorno rispetto al mese precedente. Prevede che dopo che i paesi membri dell’OPEC+ estenderanno i tagli alla produzione, ci sarà un lieve deficit di offerta quest’anno, che in precedenza era un surplus.</p>
<p>A maggio, i futures del Brent scesero di 41 centesimi, o dello 0,5%, a $85,01 al barile. Ad aprile, il petrolio greggio West Texas Intermediate (WTI) negli Stati Uniti scese di 32 centesimi, o dello 0,4%, a $80,94.</p>
<p>Il prezzo dell’oro è sceso giovedì dopo che l’indice dei prezzi alla produzione (PPI) degli Stati Uniti è aumentato più del previsto a febbraio, raffreddando le aspettative della Federal Reserve di tagliare i tassi di interesse in anticipo, e aumentando i rendimenti dei bond del tesoro e del dollaro statunitense. l’oro spot è sceso dello 0,6% a $2.161,39 per oncia, lontano dal massimo storico di $2.194,99 fissato l’8 marzo.</p>
<p>I futures dell’oro statunitense hanno chiuso in ribasso dello 0,6% a $2.167,5.</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, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>