VGVuZGVuemEgZGkgbWVyY2F0b++9nExlIHZlbmRpdGUgTkZUIGF1bWVudGFubyBkZWwgOCUgZG9wbyBtZXNpIGRpIGNhbGksIFBvbHlnb24gc2kgYXZ2aWNpbmEgYSB1biBoYXJkIGZvcmsgcXVlc3RvIG1lc2U=

2023-01-13, 03:04

<p><img src="https://gimg2.gateimg.com/image/article/1666334998%E4%B8%80%E5%91%A8%E8%A1%8C%E6%83%85.jpeg" alt=""></p>
<p>La scorsa settimana sembra aver bandito il mercato orso che ha torturato il mercato nel corso del 2022, introducendo invece un flusso di candele verdi. La maggior parte degli asset tra i primi cento questa settimana ha registrato significativi aumenti rispetto alle settimane precedenti, consentendo loro di recuperare valore e combattere la resistenza che ha afflitto il mercato.</p>
<p>Poiché il sentimento di mercato generale ora getta la luce del mercato in modo più positivo, questo ha portato con sé un’affluenza di innovazione e sviluppo attraverso blockchain, nonché la ripresa dell’interesse per le sub-industrie blockchain precedentemente lucrative. Tuttavia, nonostante queste notizie positive, gli organi di regolamentazione americani si sono abbattuti su una serie di scambi internazionali per l’offerta illecita e illegale di titoli non registrati, alimentando così la discussione sulla futuro della regolamentazione all’interno del mercato più ampio della criptovaluta.</p>
<h2 id="h2-Ultime20notizie922663"><a name="Ultime notizie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultime notizie</h2><h3 id="h3-Le20vendite20di20NFT20aumentano20dell820dopo20mesi20di20calo510556"><a name="Le vendite di NFT aumentano dell’8% dopo mesi di calo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le vendite di NFT aumentano dell’8% dopo mesi di calo</h3><p>Gli NFT sono forse state una delle industrie più colpite di qualsiasi settore del blockchain poiché il mercato dell’orso ha fatto precipitare le valutazioni di mercato, ha dichiarato fallimento delle aziende e ha diminuito l’interesse per le aree più ‘sperimentali’ di questo mondo tecnologico emergente. Questo declino è continuato per otto mesi, con vari NFT che in precedenza valevano milioni, ora valgono solo centesimi; tuttavia, c’è stato un cambiamento alla fine di dicembre, con il volume mensile delle transazioni di NFT che è aumentato del 13% per un totale di 549,5 milioni di dollari.</p>
<p>Tuttavia, l’analista Thomas Bialek di The Block Research ha attribuito questo probabilmente a una combinazione di raccolta delle perdite fiscali e rivitalizzazione delle narrazioni popolari attorno a alcuni progetti blue-chip PFP, in particolare Yuga Labs, dato il loro imminente evento ‘Trial of Jimmy The Monkey’. Se quest’ultimo è il principale fattore trainante di questo afflusso di interesse nello spazio NFT, potrebbe segnalare che ancora una volta gli NFT possono riguadagnare la loro <a href="https://www.gate.io/trade/SNT_USDT" target="_blank">Stato</a> nella blockchain e nel mainstream condividendo la loro natura strana e meravigliosa con il mondo.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673578665001.png" alt=""><br>Un esempio di NFT (Immagine cortesia di Shutterstock)</p>
<h3 id="h3-Polygon20si20avvicina20a20un20hard20fork20questo20mese146055"><a name="Polygon si avvicina a un hard fork questo mese" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Polygon si avvicina a un hard fork questo mese</h3><p>Gli sviluppatori della blockchain PoS di <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> hanno recentemente proposto il lancio di un hard fork di rete il 17 gennaio, con l’intenzione di ridurre l’impatto dei picchi delle commissioni di transazione e delle rielaborazioni della catena sulla rete di Polygon. In questo modo, gli sviluppatori aspirano ad aumentare e migliorare la rete in modo che la sicurezza dei blocchi sulle reti di sidechain possa essere migliorata e per ridurre al minimo le commissioni di gas sporadiche e volatili e l’utilizzo sulla rete. Inoltre, attraverso la riorganizzazione della catena, gli sviluppatori di Polygon sperano di proteggere meglio il mainnet di Polygon dalle rielaborazioni, considerando la storia della catena PoS di essere incline alle ‘reorgs’, portando così a confusione per quanto riguarda la verifica delle transazioni.</p>
<p>Se approvato dalla comunità, il hard fork si svolgerà più tardi questo mese come parte di un’iniziativa più ampia per migliorare le capacità tecniche del Polygon side chain, inclusi la parallelizzazione e il Polygon zkEVM.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673578723002.png" alt=""><br>Logo di Polygon (Immagine cortesia di Forbes Advisor)</p>
<h3 id="h3-La20SEC20accusa20Gemini20e20Genesis20di20offerte20di20titoli20non20registrati156630"><a name="La SEC accusa Gemini e Genesis di offerte di titoli non registrati" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La SEC accusa Gemini e Genesis di offerte di titoli non registrati</h3><p>La Securities and Exchange Commission (SEC) ha accusato gli scambi di criptovalute, Gemini e Genesis, di offerte e vendite non registrate di titoli a investitori al dettaglio, alcuni dei quali erano negli Stati Uniti. Negli ultimi anni, la SEC ha iniziato a prendere provvedimenti nei confronti di una serie di società e scambi di blockchain a causa di violazioni normative, in particolare in relazione all’offerta di titoli non registrati, con il caso Ripple vs SEC come esempio più noto.</p>
<p>Questa notizia arriva alla luce della continua faida pubblica tra i team di leadership di entrambe le società Gemini e Genesis dopo la collaborazione per offrire e vendere titoli a investitori al dettaglio tramite una piattaforma di prestito di criptovalute Gemini. Le due società si sono separate all’inizio di questo mese a seguito di uno scandalo legato ai partecipanti al programma ‘Gemini Earn’, offerto da Genesis tramite la loro piattaforma, non potendo accedere o ricevere i loro fondi a causa di presunte ‘insufficienti liquidità’ da parte di Genesis, nonostante detengano oltre 900 milioni di dollari di fondi degli investitori. Tyler Winklevoss, il co-fondatore di Gemini, ha dichiarato di essere deluso dall’azione della SEC contro Gemini, nonostante le affermazioni che lui e altri creditori stiano lavorando per recuperare i fondi dei partecipanti a Gemini Earn.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673578746003.png" alt=""><br>Gemini (Immagine cortesia di MasterTheCrypto)</p>
<h2 id="h2-Tendenze20attuali20del20progetto18981"><a name="Tendenze attuali del progetto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze attuali del progetto</h2><p>Sulla base dei dati forniti da CoinMarketCap, la maggior parte dei progetti che hanno guadagnato di più nell’ultima settimana si sono concentrati sia sul GameFi che sul Metaverso. Con entrambi questi settori che hanno subito crolli decimanti alla luce del mercato ribassista, questo improvviso rinvigorimento dell’interesse potrebbe segnalare la rinascita di questi aspetti della blockchain. Nelle ultime 24 ore, questi progetti hanno registrato pendenze fino al 467,56%, probabilmente a causa del crescente sentiment positivo all’interno del più ampio settore blockchain.</p>
<h2 id="h2-Lattuale20tendenza20del20BTC915700"><a name="L’attuale tendenza del BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’attuale tendenza del BTC</h2><p>La settimana precedente ha spronato <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> in un’inclinazione senza precedenti, consentendogli di liberarsi dalle zone di resistenza locali di $16,800 e di librarsi sopra la soglia di $18,000. Avendo guadagnato da solo l’11,34% solo questa settimana, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> I grafici orari di ’hanno rivelato che ha costantemente anticipato i dati CPI segnalati e ha continuato a testare la resistenza al rialzo di $18.238. Con i dati che si attestano al 6,5%, ci si aspetta che i tori dovranno difendere la zona di supporto di $17.609 e continuare a fornirgli l’impulso di cui ha bisogno per continuare a scambiare tra la zona di $18.238 e $18.382, come <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> rimane entro questa soglia potrebbe indicare che presto tornerà a scambiarsi sopra i $19.000, la prossima zona di resistenza chiave prevista.</p>
<p>A seguito di questo movimento positivo, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> MVRV di BTC (valore di mercato rispetto al valore effettivo) è aumentato significativamente nella scorsa settimana. All’inizio della settimana, il MVRV di BTC era pari a 0,854, il più alto delle ultime settimane, per poi salire fino a 0,934 il giorno 12. Ciò indica che BTC potrebbe finalmente allontanarsi dall’indicazione di ‘fondo di mercato’ e avvicinarsi a un territorio più stabile, segnalando che l’asset si sta muovendo verso una valutazione più realistica e completa. Tuttavia, con <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> ancora scambiare al di sotto del suo valore realizzato, questo segnala che <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> potrebbe essere un investimento valido in quanto è ancora lontano dal territorio di valutazione sano.<br><img src="https://gimg2.gateimg.com/image/article/1673578824004.png" alt=""><br>Dati mensili BTC MVRV (Dati gentilmente forniti da Blockchain.com)</p>
<h2 id="h2-Lo20stato20delle20commissioni20per20il20gas20ETH197195"><a name="Lo stato delle commissioni per il gas ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo stato delle commissioni per il gas ETH</h2><p>Al 12 gennaio si è registrata una notevole diminuzione del volume totale di gas utilizzato nell’ultima settimana rispetto a quello precedente, con il valore più basso raggiunto il 12, pari a 108.298.134.693. Il valore più alto raggiunto questa settimana è stato l’8, pari a 108.934.894.219, dimostrando un’utilizzo totale simile a quello della fine del 2022. Nonostante questa piccola variazione nel volume di gas utilizzato, il volume attuale di gas utilizzato sembra essere in linea con le tendenze mensili attuali.</p>
<p>Di conseguenza, i limiti delle commissioni di gas di <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> questa settimana hanno subito una sostanziale diminuzione rispetto alla settimana precedente. I limiti di gas bassi erano compresi tra 11 e 116 gwei, i limiti medi erano compresi tra 11 e 116 gwei e i limiti alti erano compresi tra 11 e 167 gwei - dimostrando una grande disparità nelle commissioni di gas nell’ultima settimana.</p>
<p>Nelle ultime 24 ore, i principali ‘Gas Guzzlers’ secondo Etherscan sono stati Seaport 1.1 (con commissioni totali di $269,171.70 o 191.41 ETH), <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> V3: Router 2 (con commissioni totali di $312,318.15 o 222.09 ETH) e Uniswap V2: Router 2 (con commissioni totali di $196,914.53 o 140.03 ETH) - dimostrando così un aumento significativo rispetto alla settimana precedente.</p>
<p>Il costo stimato delle transazioni su piattaforme come OpenSea: Vendita, Uniswap V3: Scambio e USDT: Trasferimento, è stato suggerito essere compreso tra $1,29 e $4,93, secondo Etherscan.</p>
<h2 id="h2-La20Situazione20Macro20Attuale903622"><a name="La Situazione Macro Attuale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Situazione Macro Attuale</h2><h3 id="h3-BTC20Influenzato20Dai20Recenti20Dati20SullIPC839623"><a name="BTC Influenzato Dai Recenti Dati Sull’IPC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC Influenzato Dai Recenti Dati Sull’IPC</h3><p>Con <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> avendo mantenuto una notevole tendenza rialzista durante la scorsa settimana, è ora di vedere se il recentemente dichiarato 6,5% CPI (Indice dei prezzi al consumo) influenzerà ulteriormente la sua valutazione. Tipicamente, se la cifra è del 6,3% o inferiore, è previsto un mercato rialzista poiché ciò rende non credibili le proiezioni della Banca Centrale degli Stati Uniti dall’ultimo FOMC, tuttavia, tra il 6,3% e il 6,5% il mercato tende ad essere contenuto, ma può continuare a salire, mentre tra il 6,5% e il 7,1% è prevista una vendita. Con JP Morgan che prevede che questi dati CPI potrebbero innescare un movimento al rialzo del 1,5-2% nell’S&amp;P 500, ciò potrebbe correlare positivamente con <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> valutazione e supporto ulteriore al suo slancio. Questo è atteso con ansia poiché <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> continua a spingere verso la soglia dei $19.000 e a liberarsi dalla sua SMA a 90 giorni.</p>
<h2 id="h2-Cosa20potrebbe20arrivare20nella20settimana20a20venire978669"><a name="Cosa potrebbe arrivare nella settimana a venire?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa potrebbe arrivare nella settimana a venire?</h2><p>Con lo stato attuale del mercato che dimostra un unanime sentimento positivo riguardo alla valutazione, all’interesse degli investitori e all’innovazione, si può affermare che la prossima settimana sarà influenzata da questi fattori, incoraggiando così questo momento apparentemente rialzista. Questo potrebbe alla fine portare a vari asset all’interno dei primi 100 continuando ad accumulare valore, mentre varie industrie all’interno della blockchain iniziano a riaffermarsi mentre l’interesse nella loro tecnologia cresce di nuovo.</p>
<div class="blog-details-info"><br><div>Autore: Ricercatore 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 venga citato Gate.io. In tutti gli altri casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>