Tm90aXppZSBxdW90aWRpYW5lIHwgTGEgc3BlY3VsYXppb25lIGRpIFJ1bmUgYXVtZW50YSBsZSBjb21taXNzaW9uaSBkaSB0cmFkaW5nIEJUQzsgV29ybGRjb2luIGhhIGxhbmNpYXRvIGxhIHJldGUgTDIgV29ybGRDaGFpbjsgU2Vjb25kbyB0dXJubyBkaSB2b3RhemlvbmUgZGVsIExhdW5jaHBhZCBMRkcgZGkgSnVwaXRlciBpbml6aWF

2024-04-18, 04:20

<p><img src="https://gimg2.gateimg.com/image/article/171341398418.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20speculazione20su20Rune20aumenta20le20commissioni20di20trading20BTC20Worldcoin20ha20lanciato20una20rete20Layer220World20Chain20Inizia20la20seconda20fase20di20votazione20LFG20Launchpad20di20Jupiter694756"><a name="Crypto Daily Digest: La speculazione su Rune aumenta le commissioni di trading BTC; Worldcoin ha lanciato una rete Layer-2 World Chain; Inizia la seconda fase di votazione LFG Launchpad di Jupiter" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La speculazione su Rune aumenta le commissioni di trading BTC; Worldcoin ha lanciato una rete Layer-2 World Chain; Inizia la seconda fase di votazione LFG Launchpad di Jupiter</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 di Farside Investor, il 6 marzo gli ETF spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> di Grayscale (GBTC) hanno registrato un deflusso di contanti pari a 133,1 milioni di dollari. Nel frattempo, gli ETF spot Bitcoin di iShares Trust (IBIT) hanno registrato un afflusso di 18,1 milioni di dollari, quelli di Bitwise (BITB) un deflusso di 7,3 milioni di dollari, quelli di ARK 21Shares (ARKB) un deflusso di 42,7 milioni di dollari e quelli di WisdomTree (BTCW) un afflusso netto di 6,6 milioni di dollari.</p>
<p>Runes è un nuovo protocollo proposto dallo sviluppatore di Bitcoin Casey Rodarmor. La sua idea principale è quella di implementare transazioni di token alternative sulla rete Bitcoin. Come il BRC-20, Runes mira a consentire il trading di nuovi token sulla rete Bitcoin. Runes utilizzerà il modello UTXO, il che significa che dovrebbe essere un’implementazione più efficace dell’emissione di token per ridurre la congestione della rete.</p>
<p>Secondo i dati di CryptoSlam, il mercato delle aspettative di Rune ha ottenuto un grande successo, con il token PUPS (attualmente BRC-20) che ha scambiato milioni di dollari al giorno questo mese. Si tratta della seconda serie NFT/BRC-20 più popolare degli ultimi sette giorni. Ogni token BRC-20 PUPS avrà la proprietà del token PUPS Runes, che verrà convertito una volta attivato Runes.</p>
<p>Tutte queste attività di hype delle rune hanno naturalmente aumentato i costi delle transazioni di Bitcoin. La media mobile di 7 giorni dei costi medi delle transazioni online è passata da $4.11 all’inizio di questo mese ai attuali $12.17.</p>
<p>Worldcoin sta per lanciare il proprio L2: World Chain. Worldcoin mira a diventare la più grande rete finanziaria e di identità. Poco prima del rilascio beta di Worldcoin nel luglio 2023, il team credeva che il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> roll-up era sufficientemente maturo e migrato al mainnet OP, compresi circa 2 milioni di utenti di world coin.</p>
<p>Tuttavia, dopo il suo effettivo lancio, Worldcoin ritiene che ci siano ancora molte aree che necessitano di miglioramento. Sebbene Worldcoin sia stata la prima applicazione su larga scala ad essere lanciata su <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> L2 (ancora la più grande applicazione ad oggi), l’ecosistema L2 è ancora nelle prime fasi per le applicazioni su larga scala.</p>
<p>La World Chain è una catena OP Stack con l’obiettivo principale di espandere la sua scala. Nel prossimo futuro, l’obiettivo è aumentare significativamente il limite di Gas dei blocchi di Layer 2. Worldcoin crede che L2 possa fornire uno nuovo spazio di trade-off e spera di esplorare attivamente l’utilizzo di Reth come client di esecuzione “nativo L2” per migliorare rapidamente le prestazioni in ambienti di produzione su larga scala.</p>
<p>Oltre alle migliorie nel livello di esecuzione, World Chain sta esplorando anche altre strutture di disponibilità dei dati (DA), compresa la DA simile a Plasma.</p>
<p>L’aggregatore DeFi Jupiter su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> sta votando sul prossimo insieme di progetti candidati per LFG Launchpad e i progetti che superano la votazione verranno lanciati a maggio e giugno. Ci sono sei candidati al progetto, tra cui il protocollo di aggregazione della liquidità Sanctum, la rete condivisa UpRock, la rete energetica decentralizzata Srcful, il progetto DEX integrato MonkeyDex, il gioco di livello AAA Nyan Heroes e il sistema di reputazione on-chain <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> ID. Questa fase di votazione terminerà il 21 aprile.</p>
<p>Votare per selezionare il miglior progetto da lanciare su Jupiter è fondamentale, poiché partecipare alla governance del DAO guadagnerà lo 0,75% dell’offerta di token, indipendentemente dal progetto per cui gli utenti votano o se viene alla fine lanciato.</p>
<h2 id="h2-Tendenze20di20mercato20BTC2020caduto20al20di20sotto20dei206000020dollari20a20meno20di20due20giorni20dal20dimezzamento20di20Bitcoin149869"><a name="Tendenze di mercato: BTC è caduto al di sotto dei 60.000 dollari, a meno di due giorni dal dimezzamento di Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC è caduto al di sotto dei 60.000 dollari, a meno di due giorni dal dimezzamento di Bitcoin</h2><p>Ieri, Bitcoin è brevemente sceso al di sotto dei 60.000 dollari, mentre gli ETF spot BTC hanno registrato deflussi netti per tre giorni consecutivi. Nel frattempo, il tasso di cambio delle Altcoin non è diminuito con la caduta di Bitcoin, e la loro performance relativa è stata relativamente forte. Meno di due giorni dal dimezzamento di Bitcoin.</p>
<p>Per quanto riguarda la macroeconomia, il mercato azionario statunitense ha registrato un significativo calo, con le azioni tecnologiche in testa alla discesa. Il mercato è stato significativamente influenzato dallo indebolimento delle aspettative di taglio dei tassi di interesse della Federal Reserve.</p>
<h2 id="h2-Hotspot20di20mercato744496"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h2><p>Gate.io ha lanciato una nuova moneta, OMNI: Dopo il lancio di OMNI, il suo prezzo è diminuito del 50%. Omini è un protocollo di interoperabilità cross Rollup costruito sul protocollo di ri-partenza Ethereum EigenLayer, mirato all’integrazione della liquidità di diversi Layer2. Nel contesto di una generale diminuzione dell’intero mercato, anche il trading on-chain sta diminuendo.</p>
<p>La catena pubblica SUI è salita bruscamente: Secondo le notizie di mercato, la collaborazione tra Sui Network e la sua controllata ByteDance ha portato a un forte aumento dei prezzi del token della catena pubblica SUI.</p>
<p>Il settore GameFi ha registrato un forte aumento di GHST: Secondo le notizie ufficiali, GHST lancerà una Base Chain e svilupperà la propria rete Layer3, aumentando significativamente i prezzi di GHST.<br>In sintesi, il mercato nel complesso mostra un trend al ribasso, ma alcuni settori e progetti caldi hanno comunque registrato un trend al rialzo. Gli investitori devono monitorare da vicino le tendenze di mercato e prendere decisioni caute.</p>
<h2 id="h2-Macro20I20tassi20dinteresse20elevati20continuano20a20minacciare20il20mercato20globale20Gli20Stati20Uniti20il20Giappone20e20la20Corea20del20Sud20hanno20lanciato20un20protocollo20trilaterale20sullintervento20valutario172486"><a name="Macro: I tassi d’interesse elevati continuano a minacciare il mercato globale; Gli Stati Uniti, il Giappone e la Corea del Sud hanno lanciato un protocollo trilaterale sull’intervento valutario" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I tassi d’interesse elevati continuano a minacciare il mercato globale; Gli Stati Uniti, il Giappone e la Corea del Sud hanno lanciato un protocollo trilaterale sull’intervento valutario</h2><p>Il 18 aprile, la situazione politica e i tassi di interesse elevati hanno continuato a mettere sotto pressione il mercato, con gli investitori che credevano che i tassi di interesse statunitensi rimanessero elevati al 4% a lungo termine. A causa dell’incertezza sui tassi di interesse e sui profitti, il sentimento degli investitori è rimasto basso. Martedì, i funzionari della banca centrale degli Stati Uniti, tra cui il presidente della Federal Reserve Powell, non hanno più indicato quando tagliare i tassi di interesse ma hanno dichiarato che la politica monetaria richiede restrizioni più lunghe.</p>
<p>Il 17 aprile, a causa degli investitori che valutavano la posizione sui tassi d’interesse della Federal Reserve e una serie di deboli relazioni finanziarie all’inizio della stagione degli utili, il mercato azionario statunitense ha registrato un calo volatile mercoledì. Il dollaro statunitense è leggermente sceso durante la notte, mentre è stato raggiunto un “protocollo trilaterale” tra Stati Uniti, Giappone e Corea del Sud, che hanno concordato “chiusi colloqui” sul mercato dei cambi nel primo dialogo finanziario trilaterale, riconoscendo le preoccupazioni di Tokyo e Seul riguardo alla recente significativa svalutazione delle loro valute.</p>
<p>Il protocollo trilaterale probabilmente aprirà la porta a misure di intervento per rallentare la crescita del dollaro USA in Asia.</p>
<p>Le prestazioni dei tre principali indici sono le seguenti: l’indice Dow Jones è sceso dello 0,12%, l’indice S&amp;P 500 è sceso dello 0,58% e l’indice Nasdaq è sceso dell’1,15%.</p>
<p>Secondo l’indagine sull’attività economica del Brown Book della Federal Reserve, l’attività economica si è leggermente espansa dalla fine di febbraio ai primi di aprile, ma le imprese sono preoccupate che il progresso nella riduzione dell’inflazione si bloccherà.</p>
<p>Lo strumento FedWatch della CME mostra che il mercato ha iniziato a digerire ampiamente le aspettative del taglio dei tassi d’interesse della Federal Reserve a giugno, con le aspettative per un taglio del tasso di almeno 25 punti base che scendono al 16,8% e le aspettative per un taglio del tasso a luglio che scendono al 46%.</p>
<p>A causa dell’asta forte di obbligazioni del tesoro a 20 anni, il rendimento delle obbligazioni del tesoro è ulteriormente diminuito rispetto al massimo registrato il giorno precedente negli ultimi mesi, e il mercato azionario ha recuperato la sua caduta, con l’ultimo prezzo dell’obbligazione del tesoro a 10 anni che si attesta a circa il 4,59%.</p>
<p>Giovedì, i mercati azionari asiatici sono leggermente aumentati in un commercio misto, mentre il dollaro statunitense si è preso una pausa mentre gli investitori rivalutavano le prospettive dei tassi di interesse e il mercato obbligazionario si stabilizzava. L’indice azionario MSCI Asia Pacific, il più ampiamente utilizzato al di fuori del Giappone, è salito dello 0,4%, ma il trend regionale è disomogeneo. L’indice Nikkei in Giappone è sceso dello 0,4% ed è diminuito del 4,3% questa settimana, segnando forse il più grande calo settimanale da dicembre 2022.</p>
<p>Per quanto riguarda le materie prime, i future sul petrolio Brent sono saliti di 10 centesimi, ovvero dello 0,11%, a $87,39 al barile, mentre i future sul petrolio statunitense sono saliti di 2 centesimi a $82,71 al barile. A causa delle preoccupazioni sulla domanda, i due indici di riferimento sono scesi del 3% nella giornata di negoziazione precedente. Parte della ragione è la riduzione delle preoccupazioni sulle sanzioni petrolifere dell’Iran e la mancanza di una risposta chiara da parte di Israele o degli Stati Uniti agli attacchi del fine settimana dell’Iran.</p>
<p>Il prezzo dell’oro è leggermente al di sotto del massimo storico della scorsa settimana di $2.366 all’oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Glassa</strong>, Ricercatore di Gate.io<br><div>Translator: 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 ripubblicare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>