Tm90aXppZSBxdW90aWRpYW5lIHwgSWwgbWVyY2F0byBjcml0dG9ncmFmaWNvIGhhIHJpcHJlc28sIGxlIGFsdGNvaW4gc29ubyBnZW5lcmFsbWVudGUgYXVtZW50YXRlOyBCbGFzdCBBaXJkcm9wIHNhcsOgIGxhbmNpYXRvOyBDb2xvc3NlbyBoYSByYWNjb2x0byAkNjBNIHBlciBpbnZlc3RpcmUgaW4gcHJvZ2V0dGkgaW4gZmFzZSBpbml

2024-06-26, 03:28

<p><img src="https://gimg2.gateimg.com/image/article/17193724221_19.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20il20mercato20delle20criptovalute20ha20registrato20un20rimbalzo20mentre20gli20Altcoin20sono20generalmente20aumentati20Il20lancio20dellairdrop20Blast2020imminente20Colosseum20ha20raccolto206020milioni20da20investire20in20progetti20in20fase20iniziale20Paradigm20ha20guidato20il20finanziamento20di203720milioni20di20Conduit4433"><a name="Riepilogo giornaliero delle criptovalute: il mercato delle criptovalute ha registrato un rimbalzo, mentre gli Altcoin sono generalmente aumentati; Il lancio dell’airdrop Blast è imminente; Colosseum ha raccolto $60 milioni da investire in progetti in fase iniziale; Paradigm ha guidato il finanziamento di $37 milioni di Conduit" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: il mercato delle criptovalute ha registrato un rimbalzo, mentre gli Altcoin sono generalmente aumentati; Il lancio dell’airdrop Blast è imminente; Colosseum ha raccolto $60 milioni da investire in progetti in fase iniziale; Paradigm ha guidato il finanziamento di $37 milioni di Conduit</h2><p>Innanzitutto, 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 giugno gli ETF Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot (GBTC) hanno registrato un deflusso di 30,3 milioni di dollari. Nel frattempo, gli ETF Fidelity Bitcoin spot (FBTC) hanno registrato un afflusso di 48,8 milioni di dollari, gli ETF Bitwise Bitcoin spot (BITB) un afflusso di 15,2 milioni di dollari e gli ETF ARK 21Shares Bitcoin spot (ARKB) un deflusso di 6,2 milioni di dollari. Dopo una settimana di deflussi netti, <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> dei fondi di trading ETF di Bitcoin è finalmente tornato positivo.</p>
<p><strong>L’airdrop di Blast sarà lanciato, distribuendo il 17% dell’offerta di token agli utenti precoci</strong><br>Layer 2 Network Blast ha annunciato i dettagli del suo prossimo airdrop. Il fondatore di Blast è anche il fondatore di Blur nel mercato NFT, che si dedica alla creazione di modelli di entrate nativi per <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> e stablecoin. La mainnet è stata precedentemente lanciata il 29 febbraio.</p>
<p>Secondo gli annunci sui social media, la Blast Foundation, l’organizzazione di governo di Blast, distribuirà la prima fase di 17 miliardi di token BLAST alle 10 del mattino ora dell’Est il 26 giugno, alle 22 ora di Hong Kong e alle 16 ora dell’Europa centrale.</p>
<p>Di questi 17 miliardi di token, il 7% sarà allocato agli utenti che aiutano a avviare la liquidità del protocollo attraverso il ponte ETH o la stablecoin USDB di Blast. Secondo il rapporto sull’economia dei token di Blast, gli utenti che guadagnano Blast Gold partecipando alle applicazioni decentralizzate riceveranno un ulteriore 7% dell’airdrop iniziale, e il restante 3% sarà assegnato alla Blur Foundation per gli airdrop retrospettivi e futuri.</p>
<p>Blast ha anche rivelato ulteriori dettagli sull’economia dei token: l’accordo prevede che il 50% dell’offerta totale di 100 miliardi di token venga allocato alle comunità e pianifica ulteriori distribuzioni aeree alle comunità nei prossimi tre anni. Il rapporto sull’economia dei token precisa inoltre che i contributori principali riceveranno il 25,5% dell’offerta di token, mentre gli investitori e la Fondazione Blast riceveranno rispettivamente il 16,5% e l’8%.</p>
<p><strong>Colosseo, un acceleratore di startup focalizzato su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, raccolto $60 milioni per investire in progetti in fase iniziale</strong><br>Colosseum è un acceleratore di startup focalizzato sull’ecosistema Solana, organizzando in modo specifico hackathon per guidare l’innovazione. La società ha raccolto $60 milioni di fondi per i suoi primi progetti di investimento e ha pianificato di investire in anticipo nel team vincitore di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Hackathons.</p>
<p>Clay Robbins, co-fondatore di Colosseum, ha detto: “Il mercato ha chiaramente una domanda di prodotti imprenditoriali innovativi e professionali nel campo della crittografia. Siamo lieti di lavorare con un gruppo diversificato di investitori per realizzare la nostra visione per il Colosseo, compresi i fondatori dell’ecosistema e gli ex partecipanti al Black Marathon.”</p>
<p>All’inizio di quest’anno, il Colosseo ha tenuto il suo primo hackathon Solana, attirando oltre 8.000 partecipanti. Matty Taylor, co-fondatore del Colosseo e ex responsabile dello sviluppo presso la Fondazione Solana, ha spiegato: “Il nostro hackathon mira a fornire un ambiente competitivo equo per i developer globali per provare lo sviluppo di prodotti crittografici e lanciare start-up on-chain.” Robbins ha aggiunto che finora, il Colosseo ha fornito 2,75 milioni di dollari di finanziamento a 11 aziende.</p>
<p>Come il Bonk DAO del Comitato Solana, che gestisce 124 milioni di dollari in token BONK e si compone di 12 individui chiave, ha intenzione di investire 500.000 dollari nel fondo.</p>
<p><strong>Paradigma e Haun Ventures hanno guidato congiuntamente il finanziamento di $37 milioni di Conduit</strong><br>Conduit, un’azienda di infrastrutture cripto, ha raccolto $37 milioni nel suo ultimo round di finanziamento per sostenere lo sviluppo di nuovi prodotti e servizi basati su blockchain. Haun Ventures e Paradigm hanno guidato congiuntamente il finanziamento della serie A, con Robot Ventures, Credible Neutral, Coinbase Ventures e Bankless Ventures che hanno partecipato anche. Inoltre, diversi investitori angelo hanno fornito finanziamenti per questo finanziamento.</p>
<p>Conduit ha dichiarato che con il miglioramento della velocità delle transazioni, la possibilità di creare prodotti e servizi disponibili on-chain per un’ampia gamma di utenti è aumentata, offrendo molte potenziali opportunità di business per gli sviluppatori di blockchain.</p>
<p>Conduit pianifica di utilizzare i fondi appena raccolti per lanciare prodotti che aiutino gli sviluppatori a costruire rollup “personalizzabili e affidabili”, i quali o soluzioni di scalabilità di Layer 2 spostano le transazioni lontano dalla rete sottostante, riducendo così la congestione di rete sulla loro blockchain. Una volta eliminati questi arretrati delle transazioni, le transazioni on-chain (come i pagamenti in criptovaluta) possono essere elaborate più velocemente.</p>
<p>Queste misure possono gettare le basi per lo sviluppo di nuovi casi d’uso per la tecnologia dei registri distribuiti. Conduit ha dichiarato in un post sul blog: “Rendendo ricca e accessibile l’elaborazione in catena, queste nuove soluzioni di estensione rendono possibili modelli di business senza precedenti.”</p>
<h2 id="h2-Tendenze20di20mercato20le20altcoin20sono20generalmente20aumentate20mentre20le20monete20Meme20come20MAGA20hanno20guidato20lintero20mercato627269"><a name="Tendenze di mercato: le altcoin sono generalmente aumentate, mentre le monete Meme come MAGA hanno guidato l’intero mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: le altcoin sono generalmente aumentate, mentre le monete Meme come MAGA hanno guidato l’intero mercato</h2><p>Il BTC è rimbalzato da ipervenduto ed attualmente si sta consolidando intorno ai 62.000$. Gli ETF spot di Bitcoin hanno registrato deflussi netti per 7 giorni consecutivi.</p>
<p>ETH ha ottenuto migliori risultati rispetto a BTC, superando i $3.400 questa mattina. Il prossimo obiettivo potrebbe essere $3.600.</p>
<p>Durante il declino di BTC ed ETH, le Altcoin hanno mostrato una performance relativamente forte e si sono riprese per prime. Le Altcoin sono generalmente aumentate, mentre le Meme coin hanno avuto una performance significativamente migliore rispetto agli altri settori.</p>
<h3 id="h3-Macroeconomia17093"><a name="Macroeconomia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia</h3><p>Nonostante le osservazioni aggressive della Federal Reserve, le azioni statunitensi hanno continuato a salire dopo un breve aggiustamento.</p>
<h3 id="h3-Punti20Caldi20del20Mercato315263"><a name="Punti Caldi del Mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato:</h3><p>Settori del meme come PEPE, BRETT, MAGA, WIF, POPCAT, ecc. hanno guidato i guadagni. MAGA è un token concettuale per le elezioni degli Stati Uniti, abbreviato come slogan di campagna di Trump Make American Great Again. MAGA è aumentato di oltre il 60% nei due giorni scorsi. Il 27 ci saranno dibattiti presidenziali tra Trump e Biden, e entrambi i candidati presidenziali hanno espresso il loro sostegno per l’industria della criptovaluta. Quindi, questo dibattito sarà un dibattito politico e un campo di battaglia d’oro sui social media, dove entrambi i candidati cercheranno di creare un momento luminoso che possa essere ampiamente diffuso nella comunità cripto.</p>
<p>La Public Chain SOL: SOL ha rimbalzato dopo essere scesa a $120 l’altro giorno ed attualmente si sta consolidando intorno ai $140. Solana ha lanciato il modulo Blinks, che consente agli utenti di utilizzare direttamente piattaforme di social media come X e Tiktok per funzioni come il trading, il voto e il pagamento. Il nuovo modulo lanciato da Solana avrà un impatto profondo sulla promozione delle criptovalute.</p>
<p>Progetto Layer2 Blast: BLAST condurrà stasera distribuzioni di token, con un totale di 100 miliardi di token e una valutazione attuale fuori dallo scambio di $3 miliardi. Dopo le scarse prestazioni dei token Layer2 sul mercato, vale la pena guardare con interesse a quale tipo di mercato BLAST emergerà.</p>
<p>L’attuale mercato delle criptovalute sta performando attivamente, con vari asset che offrono diverse opportunità di investimento. L’andamento di Bitcoin ed <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> è relativamente stabile, mentre i progetti di catene pubbliche Memecoin e SOL offrono opportunità ad alto rischio e ad alto rendimento, adatte a partecipare agli investitori con una maggiore tolleranza al rischio. La stabilità del contesto macroeconomico fornisce anche un buon supporto esterno al mercato delle criptovalute. Nel complesso, l’attuale termine partecipa attivamente a un tempo di trading di alta qualità.</p>
<h2 id="h2-Macro20Lindice20NASDAQ20ha20chiuso20in20rialzo20a20causa20del20rafforzamento20delle20azioni20tecnologiche20lindice20Dow20Jones2020diminuito20e20il20mercato20asiatico2020stato20volatile497189"><a name="Macro: L’indice NASDAQ ha chiuso in rialzo a causa del rafforzamento delle azioni tecnologiche, l’indice Dow Jones è diminuito, e il mercato asiatico è stato volatile" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: L’indice NASDAQ ha chiuso in rialzo a causa del rafforzamento delle azioni tecnologiche, l’indice Dow Jones è diminuito, e il mercato asiatico è stato volatile</h2><p>Il 25 giugno, trainato dai forti guadagni di Nvidia e dall’aumento dei prezzi delle azioni degli altri giganti tecnologici, l’indice Nasdaq è salito dell’1,3% martedì, mentre l’indice Dow Jones è sceso a causa della pressione sui prezzi delle azioni al dettaglio e degli investitori in attesa dei dati chiave sull’inflazione che verranno pubblicati questa settimana.</p>
<p>Dati specifici: il Dow Jones è sceso dello 0,76%, l’S&amp;P è salito dello 0,39% e il Nasdaq è salito dell’1,26%.</p>
<p>La società di chip per l’intelligenza artificiale Nvidia è salita del 6,8%, riprendendosi dopo tre giorni consecutivi di calo. Il settore dei chip nel complesso ha registrato una buona performance, con il Philadelphia <a href="/how-to-buy/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">comprare doge</a> L’indice Ductor aumenta dell’1,8%. I chip sono una delle principali forze trainanti dell’indice tecnologico S&amp;P 500. Alphabet è salita del 2,7%, Meta Platforms è salita del 2,3%, spingendo verso l’alto il settore dell’indice dei servizi di comunicazione.</p>
<p>A causa delle preoccupazioni sull’outlook economico, la fiducia dei consumatori negli Stati Uniti si è indebolita a giugno, ma le famiglie rimangono ottimistiche sul mercato del lavoro e si aspettano che l’inflazione si attenui nell’anno successivo. A giugno, l’indice di fiducia dei consumatori è sceso a 100,4 e il divario sul mercato del lavoro è aumentato da 22,7 a 24.</p>
<p><strong>Gli investitori rimangono cauti sui dati sull’inflazione negli Stati Uniti e i mercati azionari asiatici sono in tumulto</strong><br>Mercoledì mattina i mercati azionari asiatici hanno subito significative fluttuazioni mentre il mercato si preparava per i dati chiave sull’inflazione USA, mentre il tasso di cambio yen/dollaro si aggirava intorno a 160. I trader erano preoccupati che le autorità giapponesi potessero adottare una nuova serie di misure di intervento.</p>
<p>Le dure osservazioni degli ufficiali della Federal Reserve hanno soppresso le aspettative di recenti tagli dei tassi di interesse, aumentando così il dollaro statunitense e limitando il sentimento di rischio.</p>
<p>L’indice azionario MSCI Asia Pacific, escludendo il Giappone, è rimasto praticamente invariato nel trading volatile a 566,55, leggermente inferiore al massimo di due anni di 573,38 raggiunto la settimana scorsa. L’indice ha continuato a salire del 3,5% a giugno ed è previsto che salga per il quinto mese consecutivo. L’indice Nikkei del Giappone è salito dell’1,41%, mentre le azioni di Taiwan sono aumentate dello 0,69%, entrambe guidate da Nvidia e seguendo la tendenza dei giganti tecnologici.</p>
<p>Il mercato azionario cinese è leggermente diminuito, con le azioni blue chip e l’indice composite di Shanghai che sono scesi dello 0,2% e che si prevede diminuiranno del 4% questo mese. Anche l’indice Hang Seng di Hong Kong è sceso dello 0,16%.</p>
<p>La direttrice della Fed, Michelle Bauman, ha ribadito la sua convinzione che mantenere la stabilità dei tassi di interesse politici per un certo periodo di tempo possa essere sufficiente per controllare l’inflazione. Questi commenti, così come i dati che mostrano la stabilità nel mercato immobiliare, hanno soppresso le aspettative di mercato su quando e quanto la Federal Reserve taglierà i tassi di interesse. Lo strumento FedWatch del Chicago Mercantile Exchange mostra che il mercato si aspetta che la Federal Reserve tagli i tassi di interesse di 47 punti base quest’anno, con una probabilità del 66% di un taglio dei tassi a settembre.</p>
<p>Per quanto riguarda il mercato valutario, l’indice del dollaro statunitense, che misura il dollaro statunitense rispetto a sei valute, è rimasto stabile a 105,64, mentre il tasso di cambio dell’euro rispetto al dollaro statunitense era di 1,0715. I dati mostrano che l’indice dei prezzi al consumo è accelerato al massimo in sei mesi a maggio, riducendo la possibilità di un altro rialzo dei tassi di interesse già ad agosto, portando a un aumento del dollaro australiano. Il dollaro australiano è salito dello 0,39% rispetto al dollaro statunitense a $0,6674.</p>
<p>Il tasso di cambio attuale dello yen giapponese rispetto al dollaro statunitense è 159,79 e si sta negoziando all’interno di un range stretto, avvicinandosi al livello critico di 160. Alcuni operatori hanno espresso che questo livello potrebbe innescare una nuova fase di intervento.</p>
<p>Per quanto riguarda le materie prime, i prezzi del petrolio sono rimasti quasi invariati durante le ore di trading asiatiche, con i future sul petrolio Brent che sono rimasti stabili a $85,02 al barile e i future sul petrolio greggio West Texas Intermediate negli Stati Uniti a $80,9 al barile.</p>
<p>Il prezzo dell’oro è sceso a $2,318 per oncia, ma è comunque aumentato del 12% finora quest’anno.</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à consentita la ripubblicazione dell'articolo a condizione che sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>