UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIzIHwgU29sYW5hIHJlZ2lzdHJhIHVuIGF1bWVudG8gZGVsIHZvbHVtZSBkaSB0cmFkaW5nIGRpICQzMDAgbWlsaW9uaSwgaWwgcG9udGUgRmFudG9tIE11bHRpY2hhaW4gcHJlc3VtaWJpbG1lbnRlIGhhY2tlcmF0byBudW92YW1lbnRl

2023-07-07, 01:31

<p><img src="https://gimg2.gateimg.com/image/article/168388743720230512-182447.jpeg" alt=""></p>
<h2 id="h2-Panoramica20delle20tendenze20settimanali186148"><a name="Panoramica delle tendenze settimanali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica delle tendenze settimanali</h2><p>Nella scorsa settimana, la maggior parte delle prime 100 criptovalute ha registrato notevoli aumenti di prezzo, con pochissime che si discostano da questa tendenza, suggerendo quindi che la tendenza rialzista stia proseguendo. Queste fluttuazioni di valutazione variano dal 1,4% al 20,1%. Attualmente, la capitalizzazione di mercato globale delle criptovalute è di $1,18T.<br><img src="https://gimg2.gateimg.com/image/article/16886930661.png" alt=""><br>(Dati Cortesia di CoinmarketCap)</p>
<h2 id="h2-Mercato20delle20criptovalute322573"><a name="Mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato delle criptovalute</h2><p>🔥 <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ha registrato un’impressionante impennata oltre la soglia dei $300 milioni di volume di scambi, suscitando speranze che l’asset stia entrando in un modello di trading rialzista mentre sembra che le balene si stiano raggruppando.</p>
<p>🔥 La Commodity Futures Trading Commission (CFTC) ha accusato due uomini della Florida di aver orchestrato e condotto una frode multimilionaria. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> frode, nonché l’accusa di un uomo che manipola il suo ruolo di avvocato per truffare gli investitori.</p>
<p>Secondo quanto riportato, ci sono importanti vulnerabilità nel Multichain <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> Il ponte è stato sfruttato dagli hacker, con un presunto 7214 WETH, 1023 WBTC, 57 milioni di USDC sono stati sottratti, con il volume di DAI rubato attualmente sconosciuto.</p>
<h2 id="h2-Politiche20regolamentari923356"><a name="Politiche regolamentari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Politiche regolamentari</h2><p>🔥 USA: La criptovaluta Bittrex potrebbe potenzialmente affrontare azioni di applicazione da parte dell’Ufficio di Regolamentazione Finanziaria della Florida durante le procedure di fallimento, dopo che un deposito dai procedimenti ha suggerito che il regolatore ha ancora ‘discrezione amministrativa’ per addebitare lo scambio.</p>
<p>🔥 Asia: Sia Singapore e la Thailandia hanno introdotto misure per stringere la legislazione sulle criptovalute, con entrambi i paesi che annunciano nuove misure di protezione dei clienti che impongono nuove responsabilità agli scambi di criptovalute, tra cui il mantenimento degli asset dei clienti in un trust a Singapore e il divieto in Thailandia alle società di criptovalute di offrire prodotti di prestito e staking.</p>
<p>🔥 UK: Il Regno Unito ha promulgato una nuova legislazione innovativa sulle stablecoin in seguito alla firma della legge da parte di Re Carlo III, che conferirà ai regolatori ampi poteri per supervisionare le operazioni di stablecoin e criptovalute. Questo contribuirà a sviluppare ulteriormente un settore dei servizi finanziari robusto e tecnologicamente avanzato nel Regno Unito.</p>
<h2 id="h2-Economia20Macro99566"><a name="Economia Macro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Economia Macro</h2><p>🔥 I prezzi delle materie prime globali sono scivolati negli ultimi mesi, aggravando ulteriormente la flessione del 25% registrata nell’ultimo anno, portando alla luce la rotta economica globale e il rischio di recessione, secondo gli osservatori di mercato.</p>
<p>🔥 Recenti rapporti di mercato hanno mostrato che nei paesi ad alto reddito l’inflazione dei prezzi al consumo sta correndo a ritmi non visti da quattro decenni. In linea con questo è stato anche rivelato che i salari reali sono rimasti indietro rispetto all’inflazione crescente e ai tassi di interesse più di quanto abbiano mai fatto in precedenza.</p>
<h2 id="h2-Evidenze20del20mercato20delle20criptovalute770281"><a name="Evidenze del mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Evidenze del mercato delle criptovalute</h2><p>Gli asset provenienti da tutto l’ecosistema dei token di governance di Liquid Staking hanno registrato notevoli aumenti di valore, molti dei quali superiori al 49% nella scorsa settimana, portando il settore a crescere del 7,8% in volume nella settimana scorsa. A guidare la classifica questa settimana c’era Stader (SD), che ha registrato un aumento del 49,6% portandolo a raggiungere 1,20 $. A seguire c’era Persistence (XPRT), che ha registrato un impressionante aumento del 32,6% nella scorsa settimana. Inoltre, numerosi altri asset provenienti dall’ecosistema hanno registrato aumenti di valore comparabili, con pochissimi che si sono discostati da questo trend al rialzo.</p>
<p>⭐️ <a href="https://www.gate.io/de/blog_detail/2411/lsd-tokenomics-and-valuation-comparison" target="_blank">Per saperne di più: LSD - Tokenomica e Confronto della Valutazione</a><img src="https://gimg2.gateimg.com/image/article/16886931762.png" alt=""><br>(Dati forniti da CoinGecko)</p>
<h2 id="h2-BTC20amp20ETH20Performance20Settimanale877361"><a name="BTC &amp; ETH Performance Settimanale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC &amp; ETH Performance Settimanale</h2><h3 id="h3-Bitcoin20BTC975746"><a name="Bitcoin (BTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin (BTC)</h3><p><img src="https://gimg2.gateimg.com/image/article/16886931873.png" alt=""><br>(Dati Cortesia di TradingView)</p>
<p>Sembra che il rally rialzista di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> si sia fermato bruscamente al raggiungimento della regione di resistenza cruciale di $30k, che rappresenta una resistenza psicologica significativa ed è stata un importante ostacolo al prezzo per diversi mesi. D’altra parte, ci sono indicazioni della formazione di un modello di inversione ribassista a doppio top in concomitanza con il declino e il indebolimento del momentum rialzista, suggerendo la possibilità di una fase di inversione e consolidamento prima che il mercato determini la prossima direzione delle prestazioni di prezzo di Bitcoin. Tuttavia, se il prezzo viene respinto in questo momento critico, è possibile che si verifichi un calo verso il livello di supporto dinamico della media mobile a 100 giorni a $28k diventi altamente probabile.</p>
<h3 id="h3-Ether20ETH184280"><a name="Ether (ETH)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ether (ETH)</h3><p><img src="https://gimg2.gateimg.com/image/article/16886931994.png" alt=""><br>(Dati forniti da TradingView)</p>
<p><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>‘s prezzo ha infranto con successo la media mobile a 100 giorni, spingendolo nella trendline superiore del canale discendente, successivamente riaffrontandoli durante un pullback. Ciò ha portato ad un aumento della pressione d’acquisto e ad un significativo aumento del prezzo, raggiungendo la regione di resistenza critica di $2k. Tuttavia, il prezzo ha subito un rifiuto e ha iniziato a consolidarsi a causa della pressione di vendita prente.</p>
<h2 id="h2-Tendenza20del20progetto20Web3761683"><a name="Tendenza del progetto Web3" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenza del progetto Web3</h2><p>Questa settimana ci sono stati notevoli aumenti di valutazione e volume in tutti i principali settori patrimoniali, che coincidono con il miglioramento del sentiment di mercato nella maggior parte dell’industria delle criptovalute. Di conseguenza, l’incremento medio nei principali settori si attesta intorno al 5%, con molti token in tutte le categorie che manifestano un momento al rialzo dei prezzi.</p>
<table>
<thead>
<tr>
<th>Categoria del progetto</th>
<th>Variazione 7 giorni</th>
<th>Top 3 Guadagnatori</th>
<th>Commento</th>
</tr>
</thead>
<tbody>
<tr>
<td>Layer 1</td>
<td>+1.5%</td>
<td>XEC, CANTO, FLOW</td>
<td>I casi isolati come XEC sono aumentati di oltre il 56,6%, il che ha sostenuto il settore Layer-1.</td>
</tr>
<tr>
<td>Layer 2</td>
<td>+6.1%</td>
<td>LAI, MATIC, SKL</td>
<td>Ci sono state lievi aumenti dei prezzi in tutto il settore layer-2 mentre continua a rafforzarsi.</td>
</tr>
<tr>
<td>DeFi</td>
<td>+5.9%</td>
<td>MKR, FXS, GRT</td>
<td>DeFi ha visto un moderato rafforzamento, con molti asset che mostrano aumenti di prezzo.</td>
</tr>
<tr>
<td>NFT</td>
<td>+3.4%</td>
<td>FLOW, GQ, FINE</td>
<td>Il settore NFT ha continuato a stabilizzarsi nella scorsa settimana, portando ad aumenti di valore moderati.</td>
</tr>
<tr>
<td>MEME</td>
<td>+3.7%</td>
<td>ONIGI, SBONK, METADOGE</td>
<td>Varie meme coin hanno registrato un notevole aumento di valore nella scorsa settimana, con alcuni asset in aumento fino al 90%.</td>
</tr>
<tr>
<td>LSD</td>
<td>+4.3%</td>
<td>STKATOM, SCNSOL, STSOL</td>
<td>Il settore LSD ha visto un enorme aumento dei prezzi nell’ultima settimana, con STKATOM che ha registrato un aumento del prezzo del 36616%.</td>
</tr>
<tr>
<td>BRC-20</td>
<td>+0.8%</td>
<td>OHMS, TRAC, BSV</td>
<td>I token BRC-20 hanno principalmente registrato notevoli perdite durante questa settimana, con alcune eccezioni, come OHMS, che sostengono il settore con guadagni fino al 512%.</td>
</tr>
</tbody>
</table>
<div class="blog-details-info"><br><div>Autore: ricercatore di Gate.io: <strong>Matthew Webster-Dowsing</strong><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 il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti gli altri casi, si intraprenderanno azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>