UmljZXJjYSBzZXR0aW1hbmFsZSBzdSBXZWIzIHwgTWFzdGVyY2FyZCBzaSBhdnZpY2luYSBhbGxhIHB1YmJsaWNhemlvbmUgZGkgTXVsdGktVG9rZW4gTmV0d29yayAoTVROKSwgaSBsZWdpc2xhdG9yaSBzbG92YWNjaGkgdm90YW5vIHBlciByaWR1cnJlIGwnYWxpcXVvdGEgZmlzY2FsZSBzdWwgcmVkZGl0byBkZWxsZSBjcmlwdG92YWx

2023-06-30, 01:18

<p><img src="https://gimg2.gateimg.com/image/article/168388743720230512-182447.jpeg" alt=""></p>
<h2 id="h2-Panoramica20delle20tendenze20settimanali747617"><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 moderati incrementi di prezzo, indicando il rallentamento dell’intenso trend rialzista osservato in tutto il mercato. Queste fluttuazioni di valutazione variano dallo 0,65% al 18,16%. Attualmente, la capitalizzazione di mercato globale delle criptovalute si attesta a 1,17 T$.<br><img src="https://gimg2.gateimg.com/image/article/16880877761.png" alt=""><br>(Dati forniti da CoinmarketCap)</p>
<h2 id="h2-Mercato20criptato966975"><a name="Mercato criptato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mercato criptato</h2><p>🔥 Lunedì mattina presto BCH ha raggiunto un nuovo record annuale, ampliando il suo rally di oltre il 100% da quando è stato aggiunto all’elenco delle quattro criptovalute supportate da EDX Markets. BCH ha segnato il suo picco da maggio 2022. Per saperne di più: <a href="https://www.gate.io/blog_detail/2822/bitcoin-cash-bch-resurgence" target="_blank">Bitcoin Cash (BCH): Una Resurrezione</a></p>
<p>🔥 Mastercard si avvicina sempre di più al rilascio imminente del suo prodotto Multi-Token Network (MTN), che funge da punto di riferimento storico per l’espansione dell’azienda nello spazio della finanza digitale e della tecnologia blockchain. MTN è destinato a aumentare la sicurezza, la scalabilità e l’interoperabilità degli ecosistemi blockchain.</p>
<p>🔥 L’associazione Blockchain ha dichiarato che secondo la legge federale il presidente della SEC Gary Gensler deve fare un passo indietro dallo spazio degli asset digitali, sostenendo che Gensler sta “uscendo dai limiti loro concessi dal Congresso.”</p>
<p>La società di gestione patrimoniale internazionale, Fidelity Investments, ha presentato nuovamente la sua richiesta per una posizione di 🔥 <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF nonostante la sua richiesta non riuscita dell’anno precedente. Ad oggi, nessun istituto che ha presentato domanda per un ETF BTC è stato in grado di avere successo.</p>
<h2 id="h2-Politiche20Regolamentari79551"><a name="Politiche Regolamentari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Politiche Regolamentari</h2><p>🔥 Europa: i legislatori slovacchi hanno recentemente votato per far approvare una legislazione per regolamentare e tassare il trading e la proprietà di criptovalute a un tasso inferiore rispetto a quanto precedentemente delineato. Si prevede di ridurre l’aliquota fiscale delle criptovalute detenute per almeno un anno dalle attuali aliquote del 19% o del 25% al 7%.</p>
<p>🔥 Regno Unito: Il disegno di legge sulle criptovalute nel Regno Unito è ora ufficialmente giunto alla sua fase finale ed è attualmente in attesa dell’approvazione del re Carlo III, o del consenso reale, che è il passaggio finale richiesto per la legge diventi legge, riconfigurando così l’approccio normativo alle criptovalute nel Regno Unito.</p>
<h2 id="h2-Economia20Macro458229"><a name="Economia Macro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Economia Macro</h2><p>🔥 HSBC, una gigante bancaria britannica, ha dichiarato che gli avvertimenti di recessione sono “lampeggianti di rosso” per vari paesi e che le politiche fiscali e monetarie sono “sfasate” rispetto ai mercati azionari e obbligazionari. Di conseguenza, HSBC ha messo in guardia sulla possibilità di una recessione negli Stati Uniti entro la fine dell’anno, che inevitabilmente aprirà la strada a una recessione europea nel 2024.</p>
<p>Il primo ministro cinese Li Qiang ha dichiarato all’apertura della sessione plenaria del World Economic Forum’s Annual Meeting of the New Champions che la crescita della Cina è ancora in linea con l’obiettivo annuale di crescita di circa il 5%. Li Qiang ha dichiarato: “Da quanto possiamo vedere quest’anno, l’economia cinese mostra un chiaro slancio di ripresa e miglioramento.”</p>
<h2 id="h2-Evidenze20del20mercato20delle20criptovalute852822"><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 Synthetic Issuer hanno registrato un notevole aumento di valore, il che ha portato conseguentemente ad un aumento del 10% della valutazione dell’intero ecosistema nella scorsa settimana. Diversi asset che hanno contribuito a stimolare questa crescita sono stati oggetto di aumenti fino al 28% su base settimanale, con Mirror Protocol (MIR) che si è aggiudicato la corona, avendo registrato un aumento del 28%. Seguendo da vicino era <a href="/price/synthetix-network-snx" rel="nofollow noopener noreferrer" target="_blank">Rete Synthetix</a> (SNX), che ha visto un aumento del 15,8% del valore nell’arco degli ultimi sette giorni, dell’11,3% dei quali è stato guadagnato nelle ultime 24 ore.</p>
<p>⭐️ <a href="https://www.gate.io/de/blog_detail/974/what-is-synthetix-snx-crypto-meets-traditional-finance" target="_blank">Maggiori informazioni: Cos’è Synthetix?</a><img src="https://gimg2.gateimg.com/image/article/16880877932.png" alt=""><br>(Dati sul prezzo di MIR gentilmente forniti da CoinGecko)</p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali28583"><a name="BTC &amp; ETH Prestazioni Settimanali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC &amp; ETH Prestazioni Settimanali</h2><h3 id="h3-Bitcoin20BTC356630"><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/16880878083.png" alt=""><br>(Dati cortesia di TradingView)</p>
<p>Il 27 giugno, gli acquirenti hanno cercato di catapultare <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> sopra la zona di resistenza aerea di $31k, tuttavia gli orsi hanno rifiutato di cedere, costringendo il prezzo in un range stretto tra $31k e $29,5k. Di conseguenza, è probabile che gli orsi cercheranno di far scendere il prezzo al di sotto del fondo di $29.5k. Tuttavia, se gli orsi continuano a difendere questo livello, potrebbe indicare la forza a lungo termine del prezzo e la longevità dell’attuale gamma di prezzi. Inoltre, la media mobile esponenziale a 20 giorni in aumento (EMA) di $28.696 e l’indice di forza relativa (RSI) in territorio positivo indicano ulteriormente che il percorso di minor resistenza è verso l’alto.</p>
<p>Se si verifica un momento positivo e gli acquirenti superano la resistenza di $31k, è possibile che BTC possa continuare la sua tendenza al rialzo. Tuttavia, gli orsi potrebbero cercare di bloccare qualsiasi movimento sopra i $32.400. La prima indicazione di una sostanziale debolezza del prezzo sarebbe una chiusura al di sotto di $29,5k, che potrebbe innescare una retrazione verso la media mobile a 20 giorni. Se questo livello si rompe, BTC potrebbe essere vincolato tra $31k e $24,8k.</p>
<h3 id="h3-Ether20ETH798931"><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/16880878204.png" alt=""><br>(Dati forniti da TradingView)</p>
<p>Sul timeframe giornaliero, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> sta negoziando in un intervallo ristretto tra $1.936 e $1.861. Ciò ha spinto gli orsi a cercare di far scendere il prezzo al di sotto delle medie mobili, il che potrebbe innescare un potenziale declino verso il forte supporto di $1.700. Tuttavia, se il prezzo rimbalza dalle medie mobili, suggerirebbe una forte difesa da parte dei tori, che potrebbe segnalare una potenziale rottura del livello di resistenza di $1.937 e un potenziale rally verso il livello psicologico di $2.000.</p>
<h2 id="h2-Tendenza20del20Progetto20Web3892568"><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 state variazioni molto minori nella valutazione e nel volume in tutte le principali categorie di asset, con picchi del +0,2% e minimi del -9,6%, che possono probabilmente essere attribuiti all’attenuarsi del momentum positivo osservato nelle settimane precedenti, che ha scatenato rialzi dei prezzi in tutto il mercato. Tuttavia, gli asset individuali di ogni classe hanno registrato impressionanti rialzi dei prezzi, molti dei quali superiori all’80%.</p>
<table>
<thead>
<tr>
<th>Categoria del progetto</th>
<th>Variazione 7 giorni</th>
<th>I migliori 3 guadagni</th>
<th>Commento</th>
</tr>
</thead>
<tbody>
<tr>
<td>Layer 1</td>
<td>+0.2%</td>
<td>BCH, UNQ, INJ</td>
<td>Casi isolati come BCH sono aumentati di oltre l’80%, il che ha sostenuto il settore Layer-1.</td>
</tr>
<tr>
<td>Layer 2</td>
<td>-5.1%</td>
<td>LAI, ARB, CTSI</td>
<td>Ci sono state diminuzioni moderate dei prezzi in tutto l’ecosistema del Layer 2, con LAI che è l’unica eccezione ed è aumentata del 86% questa settimana.</td>
</tr>
<tr>
<td>DeFi</td>
<td>+0.2%</td>
<td>COMP, SRM, PENDLE</td>
<td>DeFi ha visto un moderato rafforzamento, con molti asset che mostrano notevoli incrementi di prezzo, tuttavia la maggior parte ha visto aumenti o diminuzioni di prezzo trascurabili.</td>
</tr>
<tr>
<td>NFT</td>
<td>-3.3%</td>
<td>ALU, GST-ETH, SIDUS</td>
<td>Il settore NFT è continuato a stagnare nella scorsa settimana, portando a una continua diminuzione del valore del settore.</td>
</tr>
<tr>
<td>MEME</td>
<td>-3.1%</td>
<td>SWOLE, 3D3D, TURBO</td>
<td>Il settore MEME ha visto una diminuzione di slancio nella scorsa settimana, con la maggior parte degli asset che mostrano lievi perdite.</td>
</tr>
<tr>
<td>LSD</td>
<td>-0.5%</td>
<td>MAG, STINJ, MSOL</td>
<td>Il settore LSD è stato soggetto a aumenti e diminuzioni dei prezzi moderati che non sono riusciti a avere un impatto significativo sul settore.</td>
</tr>
<tr>
<td>BRC-20</td>
<td>-9.6%</td>
<td>MAXI, MOON, SATS</td>
<td>Vari attivi hanno registrato una crescita impressionante fino al 1012% questa settimana, mentre la maggior parte ha registrato perdite fino al 96%, il che ha ulteriormente ridotto la valutazione del settore.</td>
</tr>
</tbody>
</table>
<div class="blog-details-info"><br><div>Autore: Gate.io Ricercatore: <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 venga citato Gate.io. In tutti gli altri casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>