UmljZXJjYSBzZXR0aW1hbmFsZSBXZWIz772cUmlwcGxlIGhhIG90dGVudXRvIGwnYXBwcm92YXppb25lIGluIHByaW5jaXBpbyBkZWxsYSBNQVMsIGdsaSBhc3NldCBwcm92ZW5pZW50aSBkYWxsJ2Vjb3Npc3RlbWEgQlJDLTIwIGhhbm5vIHJlZ2lzdHJhdG8gdW4gbm90ZXZvbGUgYXVtZW50byBkaSB2YWxvcmUsIGxhIGNvcHBpYSBkaSB

2023-06-23, 03:17

<p><img src="https://gimg2.gateimg.com/image/article/168388743720230512-182447.jpeg" alt=""></p>
<h2 id="h2-Panoramica20settimanale20delle20tendenze60440"><a name="Panoramica settimanale delle tendenze" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Panoramica settimanale delle tendenze</h2><p>Nel corso della settimana scorsa, la maggior parte delle prime 100 criptovalute ha registrato significativi aumenti di valore a seguito di un aumento del sentimento di mercato positivo e dell’adozione istituzionale, interrompendo così la tendenza negativa di mercato osservata di recente. Queste fluttuazioni di valore variano dal 2,06% al 45,7%. Attualmente, la capitalizzazione di mercato globale delle criptovalute ammonta a 1,17 trilioni di dollari, un aumento di 130 milioni di dollari rispetto alla settimana precedente.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16874905623841687490405_.pic.jpg" alt=""><br>(Dati forniti da CoinmarketCap)</p>
<h2 id="h2-Mercato20delle20criptovalute254409"><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/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Si è segnalato che i possessori hanno bloccato profitti per 537 milioni di dollari, secondo i dati on-chain, che rappresenta il secondo livello più alto visto nel 2023. Il profitto realizzato di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Entity-Adjusted è aumentato in modo massiccio in linea con l’ultima rally rialzista.</p>
<p>La CFTC ha accusato la società californiana Justby International Auctions di una truffa crypto ‘romantica’ a seguito di denunce che affermavano che almeno 29 clienti avevano trasferito $1,3 milioni alla società.</p>
<p>🔥 Staked <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ha raggiunto un traguardo di 20 milioni di token, raddoppiando rispetto all’inizio dell’anno, il che può essere attribuito al recente rilascio dell’aggiornamento di Shanghai e ai successivi aggiornamenti cruciali della rete Ethereum. Al momento, 38 miliardi di dollari vengono utilizzati per fare stake di Ethereum.</p>
<h2 id="h2-Politiche20regolamentari442729"><a name="Politiche regolamentari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Politiche regolamentari</h2><p>🔥 Singapore: Ripple ha annunciato di aver ottenuto l’approvazione in principio dall’Autorità Monetaria di Singapore (MAS) per la sua controllata Ripple Markets APAC Pte Ltd. Ciò consentirà a Ripple di presentare soluzioni di pagamento digitali, servizi e prodotti regolamentati a Singapore.</p>
<p>🔥 USA: Negli Stati Uniti è emersa di recente una proposta bipartisan per stabilire un quadro normativo in mezzo alla corsa globale per regolamentare e controllare il ruolo che l’AI ha nella società. Di conseguenza, è stata proposta una commissione per affrontare il problema urgente.</p>
<p>🔥 Francia: Il governatore della Banca di Francia, Villeroy de Galhau, ha chiesto una seconda iterazione del quadro normativo MiCA come mezzo per supervisionare i conglomerati crittografici, come mezzo per fare luce sulla necessità di cooperazione internazionale nella regolamentazione delle grandi aziende criptografiche.</p>
<h2 id="h2-Economia20macro385313"><a name="Economia macro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Economia macro</h2><p>🔥 Il ministro delle Finanze saudita, Mohammed Al-Jadaan, ha dichiarato che il volume delle recenti sfide economiche globali ha influenzato in modo sostanziale lo sviluppo dei paesi a basso reddito. Di conseguenza, il Ministro ha affermato che l’insicurezza alimentare e l’accesso insufficiente all’acqua e all’energia sono stati aggravati dalla crisi economica globale.</p>
<p>🔥 Con la terribile crisi economica in Pakistan, il primo ministro Shehbaz Sharif ha fatto appello al Fondo monetario internazionale (FMI) per sbloccare la tranche da 1,1 miliardi di dollari, in sospeso dal novembre 2022. Secondo Sharif, il Pakistan ha soddisfatto tutti i requisiti richiesti dal prestatore e che la nazione è “pienamente impegnata” ad adempiere ai propri obblighi.</p>
<h2 id="h2-Evidenze20del20mercato20delle20criptovalute822135"><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 BRC-20 hanno registrato un notevole aumento di valore nella scorsa settimana, portando l’intero settore a crescere del 27,8%, spingendo la capitalizzazione di mercato a quasi 270 milioni di dollari. Il maggior guadagno dell’intero settore è stato PEPE (Ordinali), che ha registrato un aumento del 7.289.158.311% nelle ultime 24 ore, portando la sua valutazione a un impressionante 0,054740 dollari. In netto ritardo rispetto a PEPE (Ordinali) ma comunque dimostrando una crescita notevole, c’era TRAC (Ordinali) che ha registrato un aumento del 44%.</p>
<p>⭐️ Maggiori informazioni: <a href="https://www.gate.io/de/blog_detail/2598/what-spurred-the-development-of-brc-20-and-how-will-it-affect-the-future-of-btc" target="_blank">Cosa ha spinto lo sviluppo di BRC-20 e come influenzerà il futuro di BTC?</a></p>
<p><img src="https://gimg2.gateimg.com/image/article/16874906363861687490474_.pic.jpg" alt=""><br>(Dati forniti da CoinGecko)</p>
<h2 id="h2-BTC20amp20ETH20Prestazioni20Settimanali15177"><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-Bitcoin20BTC873429"><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/16874906713871687490506_.pic.jpg" alt=""><br>(Dati forniti da TradingView)</p>
<p>A partire da oggi, Bitcoin ha superato e chiuso sopra la media mobile esponenziale a 20 giorni (EMA) di $26.934 il 17 giugno, spingendolo a un massimo settimanale di $30.613, permettendogli di superare la zona di resistenza a $30k e stabilire un canale di trading rialzista. Ciò ha portato BTC a stabilire $25k come nuovo livello di supporto e superare la media mobile a 50 giorni di $27k. Se il breakout rialzista continua, Bitcoin potrebbe essere avvolto in <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> da parte degli operatori, il che potrebbe spingerlo ulteriormente al rialzo nel medio termine e portarlo a testare la prossima area di resistenza sostanziale situata intorno a $38k.</p>
<p>D’altra parte, gli orsi sono improbabili di arrendersi così facilmente contro i tori, poiché è previsto che cercheranno di fermare il rally a 31.000 dollari, tuttavia, se i tori non vacillano nel loro aggancio aggressivo al livello attuale, potrebbe migliorare le prospettive di un rally al di sopra della resistenza aerea. Se ciò accade, potrebbe spingere la coppia <a href="/trade/BTC_USDT" target="_blank" class="blog_inner_link">BTC/USDT</a> a salire a circa 32.400 dollari, che si prevede che gli orsi difenderanno, ma se ciò fallisce, la coppia potrebbe salire a 40.000 dollari.</p>
<h3 id="h3-Ether20ETH561999"><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/16874907343881687490527_.pic.jpg" alt=""><br>(Dati cortesia di TradingView)</p>
<p>Il prezzo di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha mostrato resilienza nei mesi scorsi, portando a un’oscillazione tra i livelli psicologici di $1-2k, mentre mostra una consolidazione stretta sul grafico a tre giorni. Man mano che questo movimento rangebound si avvicina a una rottura, gli investitori devono essere estremamente cauti nei confronti degli orsi di Bitcoin che stanno cercando di far scendere il prezzo, il che potrebbe capovolgere il potenziale di Ethereum di riuscire a passare attraverso la formazione dell’apice del triangolo ed esperire una rottura volatile verso il target di $2,915.</p>
<h2 id="h2-Tendenza20del20progetto20Web3239426"><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, c’è stata una sostanziale valutazione e un aumento del volume in tutti i principali settori degli asset, che coincide con il rinnovato sentimento di mercato ottimista, che ha spinto molti asset in rialzo dei prezzi. Di conseguenza, l’aumento medio in tutti i principali settori raggiunge circa il 10%, con molti token in ciascun settore che aumentano in modo significativo.</p>
<table>
<thead>
<tr>
<th>Categoria del progetto</th>
<th>Variazione a 7 giorni</th>
<th>Top 3 Vincitori</th>
<th>Commento</th>
</tr>
</thead>
<tbody>
<tr>
<td>Layer 1</td>
<td>+17.1%</td>
<td>NEXA, BCH, KAS</td>
<td>Il settore Layer-1 ha registrato consistenti aumenti di prezzo nel corso dell’ultima settimana, con una media di circa il 25% per ogni asset.</td>
</tr>
<tr>
<td>Layer 2</td>
<td>+11.4%</td>
<td>OP, ARB, IMZ</td>
<td>C’è stato un importante aumento dei prezzi in tutto il settore del layer-2 mentre inizia a rafforzarsi.</td>
</tr>
<tr>
<td>DeFi</td>
<td>+10.7%</td>
<td>SRM, PENDLE, FLM</td>
<td>DeFi ha visto un significativo rafforzamento, con molti asset che mostrano notevoli aumenti di prezzo.</td>
</tr>
<tr>
<td>NFT</td>
<td>+14.4%</td>
<td>VEED, VEE, NTVRK</td>
<td>Il settore NFT ha rotto la sua recente tendenza di stagnazione e ha guadagnato una significativa trazione nell’ultima settimana.</td>
</tr>
<tr>
<td>MEME</td>
<td>+15.3%</td>
<td>KABOSU, SHIBAKEN, SWOLE</td>
<td>Diverse meme coin hanno continuato ad accelerare in volume, riaccese quindi l’interesse nel settore.</td>
</tr>
<tr>
<td>LSD</td>
<td>+16.5%</td>
<td>DVT, SCNSOL, STOSMO</td>
<td>Il settore LSD ha registrato guadagni consistenti su quasi ogni token nell’ecosistema.</td>
</tr>
<tr>
<td>BRC-20</td>
<td>+27.7%</td>
<td>PEPE (Ordinali), OSHI, WHEE</td>
<td>I token BRC-20 hanno registrato un’enorme crescita di interesse dopo settimane di stagnazione.</td>
</tr>
</tbody>
</table>
<div class="blog-details-info"><br><div>Autore:<strong>Matthew Webster-Dowsing</strong>, Ricercatore di Gate.io<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 i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>