Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIHN1cGVyYSBkaSBudW92byBpIDcwLjAwMCBkb2xsYXJpOyBQYXJhU3dhcCBjb3JyZWdnZSBsZSB2dWxuZXJhYmlsaXTDoCBlIHJlc3RpdHVpc2NlIGxlIG1vbmV0ZSBhZ2xpIHV0ZW50aTsgQXZhbGFuY2hlIGNvbGxhYm9yYSBjb24gQU5aIEJhbmsgcGVyIGVmZmV0dHVhcmUgaWwgcmVnb2xhbWV

2024-03-26, 04:06

<p><img src="https://gimg2.gateimg.com/image/article/17114259461_18.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20BTC20supera20di20nuovo20i207000020ParaSwap20risolve20le20vulnerabilit20e20restituisce20le20monete20agli20utenti20Avalanche20collabora20con20Chainlink20per20effettuare20il20regolamento20degli20asset20onchain20in20Australia300530"><a name="Crypto Daily Digest: BTC supera di nuovo i $70.000; ParaSwap risolve le vulnerabilità e restituisce le monete agli utenti; Avalanche collabora con Chainlink per effettuare il regolamento degli asset on-chain in Australia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: BTC supera di nuovo i $70.000; ParaSwap risolve le vulnerabilità e restituisce le monete agli utenti; <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> collabora con Chainlink per effettuare il regolamento degli asset on-chain in Australia</h2><p>In primo luogo, 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 marzo i fondi GBTC di Grayscale hanno continuato a… <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> raggiungendo un valore significativamente più alto, arrivando a $350,1 milioni. Nel frattempo, l’afflusso di Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) è stato di $261,8 milioni e l’afflusso di Bitwise Bitcoin spot ETF (BITB) è stato di $14 milioni.</p>
<p>Il Bitcoin è tornato al suo livello di 70.000 dollari il 25 marzo, raggiungendo un massimo di 9 giorni. Questa tendenza al rialzo ha recuperato le perdite della settimana precedente, facendo dubitare ai trader se raggiungerà un nuovo massimo storico. Il mercato degli ETF Bitcoin spot è dominato da un deflusso di fondi di 2 miliardi di dollari da GBTC, con deflussi superiori agli afflussi per la prima volta in 7 settimane. Tuttavia, nonostante questi deflussi di fondi, gli afflussi degli ETF Bitcoin spot sono aumentati di 1,1 miliardi di dollari questa settimana.</p>
<p>Secondo i dati di CoinShares, gli investitori istituzionali hanno investito 12,3 miliardi di dollari nel settore delle criptovalute nel 2024. Per quanto riguarda lo sfondo, nel corso del 2021 i prodotti cripto hanno registrato un afflusso annuale di 10,6 miliardi di dollari.</p>
<p>L’aggregatore DeFi ParaSwap ha risolto una vulnerabilità critica nel nuovo contratto intelligente August V6 lanciato la scorsa settimana e sta ora restituendo criptovalute agli utenti.</p>
<p>ParaSwap ha scoperto questa vulnerabilità nel suo nuovo contratto intelligente Augustus V6, lanciato a marzo 20, solo pochi giorni dopo il lancio del contratto 18 agosto, con l’obiettivo di migliorare gli scambi di token e ridurre le commissioni di trasferimento. Dopo la scoperta, la piattaforma ha sospeso l’interfaccia di programmazione dell’applicazione (API) e ha garantito la sicurezza finanziaria attraverso attacchi di hacking white hat.</p>
<p>Il 24 marzo, il team di Paraswap ha rilasciato una dichiarazione su X affermando che tutti gli asset erano stati restituiti al portafoglio recuperato con successo dal white hat hacker e che l’autorizzazione ad AugustusV6 era stata revocata.</p>
<p>Il Gruppo Bancario Australiano e della Nuova Zelanda (ANZ) e Chainlink Labs hanno pubblicato recenti risultati di collaborazione mirati a connettersi <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> e il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> rete blockchain per fornire soluzioni di regolamento on chain. ANZ ha utilizzato una soluzione di interoperabilità fornita da Chainlink chiamata Cross Chain Interoperability Protocol (CCIP), che consente di dimostrare come i clienti possono accedere, scambiare e regolare in modo trasparente asset tokenizzati su reti in diverse valute.</p>
<p>Attraverso CCIP, ANZ simula l’acquisto di asset tokenizzati sulla rete <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> a un prezzo denominato in una stablecoin, e avvia e regola le transazioni su Avalanche utilizzando un’altra stablecoin.</p>
<p>ANZ Bank ha dichiarato che l’obiettivo del progetto è quello di implementare la soluzione sulla mainnet blockchain, promuovendo una nuova era di regolamento degli asset su blockchain nell’industria dei servizi finanziari.</p>
<p>Questo è anche un passo per Avalanche per spostare il suo focus verso la direzione RWA. Ad esempio, a febbraio di quest’anno, Citigroup, una banca d’investimento statunitense e fornitore di servizi finanziari, ha collaborato con lo sviluppatore di Avalanche Network, Ava Labs, per completare la convalida concettuale della tokenizzazione dei fondi di private equity attraverso la blockchain di Avalanche.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20ritorna20a207000020Il20settore20RWA20continua20a20salire635549"><a name="Tendenze di mercato: BTC ritorna a $70,000; Il settore RWA continua a salire" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC ritorna a $70,000; Il settore RWA continua a salire</h2><p>Il mercato cripto complessivo mostra una tendenza al rialzo stabile, soprattutto con Bitcoin (BTC) che torna sopra i $70.000, indicando un mercato relativamente forte. Tuttavia, dal punto di vista macroeconomico, c’è stato un declino collettivo del mercato azionario statunitense e il tasso di cambio RMB offshore è sceso anche sotto 7,28, il che potrebbe avere un certo impatto sul mercato cripto e richiedere attenzione.</p>
<h3 id="h3-Punti20Caldi20del20Mercato327660"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>Il settore RWA ha mostrato una forte performance: i token nel settore RWA (Real World Assets), come POLYX, ONDO, OM, TOKEN, DUSK, RSR, TRU, ecc., hanno registrato guadagni consistenti. Questo fenomeno potrebbe essere correlato all’annuncio di BlackRock di istituire fondi tokenizzati, a indicare l’attenzione e la ricerca del mercato verso la digitalizzazione degli asset reali.</p>
<p>Inoltre, ci sono diversi progetti cripto con sblocco del token questa settimana, tra cui:</p>
<ol>
<li><p>Yield Guild Games (YGG) sbloccherà 16,69 milioni di token del valore approssimativo di 16,89 milioni di dollari alle 14:00 (UTC) del 27 marzo, corrispondenti al 5,39% dell’offerta circolante;</p>
</li><li><p>SingularityNET (AGIX) sbloccherà 8,84 milioni di token dal valore approssimativo di $9,26 milioni alle 0:00 (UTC) del 28 marzo, corrispondenti al 0,69% dell’offerta circolante;</p>
</li><li><p><a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> (OP) sbloccherà 24,16 milioni di token del valore di circa 84,32 milioni di dollari alle 4:00 (UTC) del 29 marzo, pari al 2,4% dell’offerta circolante;</p>
</li><li><p>EchelonPrime (PRIME) sbloccherà 1,66 milioni di token del valore approssimativo di $37,53 milioni alle 0:00 (UTC) del 31 marzo, rappresentando il 4,65% dell’offerta circolante;</p>
</li><li><p>Sui (SUI) sbloccherà 4 milioni di token del valore approssimativo di $6,68 milioni alle 0:00 (UTC) del 31 marzo, corrispondenti al 0,32% dell’offerta circolante. Questi dati sbloccati potrebbero influenzare l’offerta e i prezzi di mercato, e le reazioni di mercato devono essere monitorate.</p>
</li></ol>
<p>Sulla base dell’analisi sopra riportata, il mercato delle criptovalute mostra complessivamente una tendenza al rialzo stabile. Tuttavia, bisogna ancora prestare attenzione all’impatto dei fattori macroeconomici e allo sblocco di progetti specifici sul mercato.</p>
<p>Specialmente con lo sviluppo continuo della tendenza alla digitalizzazione degli asset del mondo reale, l’attenzione del settore RWA sta aumentando gradualmente e gli investitori possono monitorare da vicino le opportunità di investimento in questo campo. Nel frattempo, per i progetti sbloccati questa settimana, è necessario valutare attentamente il loro impatto sul mercato e sviluppare strategie di investimento in base alla situazione reale.</p>
<h2 id="h2-Macro20Wall20Street2020sceso20prima20delluscita20dei20dati20importanti20Le20tensioni20geopolitiche20potrebbero20far20aumentare20i20prezzi20del20petrolio671573"><a name="Macro: Wall Street è sceso prima dell’uscita dei dati importanti; Le tensioni geopolitiche potrebbero far aumentare i prezzi del petrolio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wall Street è sceso prima dell’uscita dei dati importanti; Le tensioni geopolitiche potrebbero far aumentare i prezzi del petrolio</h2><p>La Federal Reserve ha deciso mercoledì scorso di mantenere invariati i tassi di interesse chiave della politica monetaria e il suo “Policy Path Chart” riflette ancora l’aspettativa di tre tagli dei tassi quest’anno. A causa della relativamente scarsa quantità di dati economici questa settimana, l’attenzione del mercato si è spostata sul rapporto sulla spesa per consumi personali (PCE) pubblicato venerdì. Ciò potrebbe guidare la direzione delle prospettive per i tassi di interesse negli Stati Uniti. Si prevede che l’indice dei prezzi di consumo personale essenziale (PCE) negli Stati Uniti aumenti dello 0,3% a febbraio, con un tasso di crescita annuale del 2,8%.</p>
<p>L’analista di mercato di IG, Tony Sycamore, ha dichiarato: “All’inizio di quest’anno, il presidente della Federal Reserve ha cercato di liberare il mercato dalle aspettative aggressive sui tassi di interesse, e ha sempre creduto che questo sarebbe stato un percorso accidentato.”</p>
<p>La scorsa settimana, il presidente della Federal Reserve Jerome Powell ha ridimensionato le prospettive sull’inflazione, riportando i tagli dei tassi di interesse all’ordine del giorno.</p>
<p>Il tasso di allentamento previsto per giugno è del 75%, in diminuzione rispetto al 55% della settimana scorsa. Questo tasso è stato incluso nei tre o quattro tagli dei tassi di interesse quest’anno. Powell presiederà la riunione di politica di venerdì, e i direttori della Federal Reserve Lisa Cook e Christopher Waller parteciperanno anche a questa settimana.</p>
<p>Prima che i dati fossero resi disponibili, Wall Street ha chiuso in ribasso, con il Dow Jones Industrial Average (.DJI) che è sceso di 162,26 punti, o dello 0,41%, a 39.313,64 punti, l’indice S&amp;P 500 che è sceso a 5.218,19 punti o dello 0,31%, e il Nasdaq Composite Index (.IXIC) che è sceso di 44,35 punti, o dello 0,27%, a 16.384,47.</p>
<p>Nel commercio di materie prime, i prezzi dell’oro e del petrolio sono rimasti relativamente stabili, con i prezzi dell’oro spot a $2,169 per oncia e i futures sul petrolio Brent in aumento di 24 centesimi a $86.99 al barile.</p>
<p>Tuttavia, è probabile che la situazione politica globale influenzi anche i prezzi del petrolio. La Russia chiede alle sue compagnie petrolifere di ridurre la produzione per raggiungere l’obiettivo dell’Organizzazione dei Paesi Esportatori di Petrolio (OPEC) di 9 milioni di barili al giorno (bpd). La produzione giornaliera della Russia era di circa 9,5 milioni di barili alla fine di febbraio. Nel frattempo, gli attacchi dell’Ucraina alle raffinerie russe continuano. La raffineria di Gubyshev in Russia ha dovuto chiudere la metà della sua capacità produttiva dopo che è scoppiato un incendio sabato mattina.</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 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>