Tm90aXppZSBxdW90aWRpYW5lIHwgT3JkaW5hbHMgcmlsYXNjaWEgR2VuZXNpcyBSdW5lLCBXb3JtaG9sZSBpbml6aWEgbGUgcmljaGllc3RlIGRpIGFpcmRyb3A7IExhIG51b3ZhIGZhc2UgZGVsIHByb2dyYW1tYSBkaSBmaW5hbnppYW1lbnRvIGRlbGxhIEZvbmRhemlvbmUgQXJiaXRydW07IElsIG1lcmNhdG8gZ2xvYmFsZSDDqCBwaWF

2024-04-01, 04:11

<p><img src="https://gimg2.gateimg.com/image/article/17119446131_2.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Il20fondatore20di20Ordinals20ha20rilasciato20la20rune20di20genesi20e20Wormhole20ha20annunciato20linizio20delle20richieste20di20airdrop20La20terza20fase20del20programma20di20finanziamento20della20Fondazione20Arbitrum185643"><a name="Crypto Daily Digest: Il fondatore di Ordinals ha rilasciato la rune di genesi, e Wormhole ha annunciato l’inizio delle richieste di airdrop; La terza fase del programma di finanziamento della Fondazione Arbitrum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Il fondatore di Ordinals ha rilasciato la rune di genesi, e Wormhole ha annunciato l’inizio delle richieste di airdrop; La terza fase del programma di finanziamento della Fondazione Arbitrum</h2><p>Il mercato è chiuso il venerdì e non vi è attività di trading per <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETFs.</p>
<p>Casey, il fondatore del protocollo <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> NFT Ordinals, ha rilasciato il documento Runes, consentendo a Bitcoin di scambiare beni digitali nativi incisi, coniati e trasferiti. Sebbene ogni iscrizione sia unica, ogni unità del rune è la stessa; sono token intercambiabili adatti a vari scopi.</p>
<p>Ha pubblicato sulla piattaforma X affermando che una buona caratteristica delle rune è che la terminologia di conio è molto flessibile ed espressiva. Oltre al numero massimo di conio, gli utenti possono anche specificare gli orari di inizio e fine, che sono altezze di blocco assolute e conteggi relativi di blocchi dopo che l’incisione è stata scavata.</p>
<p>Il 1° aprile, Casey ha annunciato il rilascio del genesis Rune UNCOMMON•GOODS, che aprirà la produzione dopo la riduzione a metà fino al blocco successivo della riduzione a metà, ed è un numero illimitato di rune con blocchi limitati. Questa runa può essere prodotta una sola volta e ha una separabilità di zero.</p>
<p>Il protocollo cross-chain Wormhole ha annunciato sulla piattaforma X che le richieste di airdrop inizieranno alle 11:30 (UTC) del 3 aprile 2024.</p>
<p>Wormhole è un protocollo di trasmissione delle informazioni distribuito e universale tra le catene di blocco, con l’obiettivo di realizzare la trasmissione di asset e informazioni tra le reti blockchain. Come mezzo di comunicazione per blockchain o Rollups, questo protocollo fornisce attualmente agli sviluppatori oltre 30 canali di liquidità e utenti su reti blockchain principali, coprendo vari scenari di richiesta come DeFi, NFT e governance. Nel 2023, ha completato un nuovo round di finanziamento con una valutazione di 2,5 miliardi di dollari.</p>
<p>Il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La soluzione Layer2, Arbitrum, potrebbe lanciare un nuovo programma di finanziamento. La Fondazione Arbitrum ha annunciato che la seconda fase del suo programma di finanziamento, il Programma di sovvenzioni delle Fondazioni di Arbitrum, è stata completata, con una scadenza per le richieste entro il 3 aprile 2024.</p>
<p>Il terzo stadio sta per iniziare: le nuove richieste saranno accettate il 15 aprile 2024 e continueranno fino alla fine di giugno. In questa fase, la fondazione continuerà a concentrarsi sul campo dApp ma introdurrà metodi di finanziamento più standardizzati, concentrandosi principalmente su progetti verticali come giochi, NFT, social media, DAO, DeFi, ecc.</p>
<h2 id="h2-Tendenze20di20mercato20landamento20orizzontale20ad20alto20livello20di20BTC20il20progetto20dellecosistema20di20Solana2020in20crescita502096"><a name="Tendenze di mercato: l’andamento orizzontale ad alto livello di BTC, il progetto dell’ecosistema di Solana è in crescita" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: l’andamento orizzontale ad alto livello di BTC, il progetto dell’ecosistema di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> è in crescita</h2><p>Bitcoin (BTC) rimane sopra i 70.000 dollari e il mercato generale mostra un trend di volatilità al rialzo. Attualmente, le speculazioni di mercato si concentrano principalmente sulla <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e gli ecosistemi di base, mentre molti progetti di moneta on-chain 100x sono emersi. Sul fronte macroeconomico, il mercato azionario statunitense è stato chiuso per le vacanze pasquali, mentre i dati sull’inflazione dell’indice dei prezzi delle spese dei consumatori personali degli Stati Uniti (PCE) sono stati in linea con le aspettative.</p>
<h3 id="h3-Hotspot20di20mercato798543"><a name="Hotspot di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato</h3><p>Il boom dell’ecosistema di Solana: i prezzi di SOL sono aumentati notevolmente, raggiungendo oltre i $200, trainando le valute come WIF, BOME, JUP, JTO e RAY per i progetti dell’ecosistema di Solana. Vale la pena notare che il valore di mercato dei progetti Jito e Jupiter sulla catena di Solana ha superato progetti simili, Lido e <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, nell’ecosistema Ethereum. Inoltre, il progetto Meme sulla catena Solana è ancora attivo, soprattutto con l’emergere di molti Meme simili a gatti.</p>
<p>La Base Chain ha ricevuto attenzione: i numerosi progetti Meme sulla Base Chain hanno attirato la maggior parte dell’attenzione del mercato nel weekend, con MFER che è aumentato di 100 volte in soli due giorni. Al momento, il numero di indirizzi sulla Base Chain ha superato i 5,5 milioni, e il volume delle transazioni ha raggiunto anche un livello storico.</p>
<p>CORE rise: Il prezzo della catena pubblica CORE è aumentato di oltre 5 volte in una sola settimana, e tassi negativi fino a -0,08% sono apparsi nel contratto di scambio di Gate.io, indicando un chiaro sentimento bearish nel mercato.</p>
<p>Il protocollo stablecoin LQTY ha registrato un aumento significativo: il prezzo di LQTY è aumentato di oltre il 20% in un solo giorno e, a causa dell’impatto del progetto imminente ETHNA, il mercato ha scommesso in anticipo su progetti simili.</p>
<p>Il PENDLE di LSDfi ha raggiunto un nuovo massimo storico: il PENDLE ha di nuovo raggiunto un nuovo massimo storico e il suo TVL (Totale Valore Bloccato) ha raggiunto anch’esso un nuovo massimo storico. La ristaking track rimane una delle storie più interessanti in questo mercato toro.</p>
<p>Nel complesso, i punti caldi del mercato sono concentrati in aree come l’ecosistema Solana, l’ecosistema Base e l’LSDfi. Gli investitori dovrebbero monitorare attentamente questi hotspot e adeguare le loro strategie di investimento in modo tempestivo in base alle condizioni di mercato, prestando attenzione nel rispondere ai rischi di mercato.</p>
<h2 id="h2-Macro20La20festa20di20Pasqua20ha20portato20ad20un20mercato20noioso20e20gli20investitori20scommettono20che20la20stretta20offerta20porter20ad20un20aumento20dei20prezzi20del20petrolio789658"><a name="Macro: La festa di Pasqua ha portato ad un mercato noioso, e gli investitori scommettono che la stretta offerta porterà ad un aumento dei prezzi del petrolio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: La festa di Pasqua ha portato ad un mercato noioso, e gli investitori scommettono che la stretta offerta porterà ad un aumento dei prezzi del petrolio</h2><p>Il 29 marzo, a causa della chiusura di molti paesi per le vacanze pasquali, il volume di scambi del mercato globale ha mostrato una tendenza poco brillante. I dati pubblicati venerdì scorso dal Dipartimento del Commercio degli Stati Uniti, Ufficio per l’analisi economica, hanno mostrato che l’indice dei prezzi della spesa personale (PCE) è aumentato dello 0,3% a febbraio, inferiore all’incremento dello 0,4% previsto in precedenza dagli economisti intervistati da Reuters.</p>
<p>Il yen giapponese ha raggiunto un minimo di 34 anni di 151,975 contro il dollaro americano mercoledì e ha leggermente ripreso contro il dollaro americano lunedì, salendo leggermente a 151,315.</p>
<p>La pubblicazione dei dati PCE ha consolidato le aspettative di mercato per un taglio dei tassi a giugno, portando a una prestazione relativamente stabile del dollaro statunitense e dello yen giapponese che diventa l’attenzione del mercato. Il tasso di cambio USD/JPY rimane intorno a 152, il che rende i trader nervosi per i potenziali rischi del tasso di cambio USD/JPY e potrebbe richiedere un intervento per stabilizzare la situazione.</p>
<p>Per quanto riguarda il mercato asiatico, la Corea del Sud ha mostrato un sesto mese consecutivo di crescita nelle esportazioni di chip a marzo, con un aumento delle esportazioni del 3,1% rispetto allo stesso periodo dell’anno scorso e del 4,8% un mese fa. Questo è anche una manifestazione del momento per la ripresa economica globale, poiché la posizione della Corea del Sud nei settori dei semiconduttori e di altri prodotti ad alta tecnologia la rende un barometro della domanda globale. Allo stesso tempo, la Cina ha criticato gli Stati Uniti per il rafforzamento delle normative sulle esportazioni di semiconduttori, affermando che tali normative hanno creato ulteriori ostacoli al commercio e aggiunto maggiore incertezza all’industria dei chip.</p>
<p>Per quanto riguarda le materie prime, nonostante un leggero calo dei prezzi del petrolio lunedì, le aspettative di una stretta di rifornimento, gli attacchi alle raffinerie russe e i dati ottimistici sulla produzione manifatturiera cinese continuano a sostenere la maggior parte dell’incremento recente dei prezzi del petrolio.</p>
<p>I prezzi del petrolio greggio Brent sono scesi di 17 centesimi, o dello 0,2%, a $86,83 al barile, in aumento del 2,4% la settimana scorsa. Il prezzo del petrolio greggio medio del Texas occidentale negli Stati Uniti è sceso di 11 centesimi, o dello 0,1%, a $83,06 al barile, a seguito di un aumento del 3,2% la settimana scorsa.</p>
<p>Il vice primo ministro russo Alexander Novak ha dichiarato venerdì scorso che Rosneft si concentrerà sulla riduzione della produzione anziché sulle esportazioni nel secondo trimestre, per distribuire in modo equo la riduzione con gli altri paesi membri dell’OPEC+. Gli analisti sottolineano che i rischi geopolitici che affrontano l’approvvigionamento di petrolio greggio e materie prime pesanti hanno exacerbato i forti fondamentali della domanda degli ultimi 24 anni nel secondo trimestre.</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 suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>