VGVuZGVuemEgZGkgbWVyY2F0b++9nElsIGxhbmNpbyBkaSBMYXllci0yIGRpIENvaW5iYXNlIMOoIHN0YXRvIGFjY2lkZW50YXRvOyBJbCBDRU8gZGkgQ2lyY2xlIHNpIG9wcG9uZSBhbGxhIFNFQyBjaGUgc2kgbXVvdmUgcGVyIHJlZ29sYW1lbnRhcmUgbGUgc3RhYmxlY29pbg==

2023-02-24, 03:24

<p><img src="https://gimg2.gateimg.com/image/article/1666334998%E4%B8%80%E5%91%A8%E8%A1%8C%E6%83%85.jpeg" alt=""><br>Nella scorsa settimana, il mercato delle criptovalute ha subito una serie di alti e bassi, con aumenti di prezzo positivi e declini graduali. Tra le prime 10, la maggior parte degli asset ha iniziato a perdere fino al 5% del proprio valore totale, tuttavia la restante parte delle prime 100 sembra ancora capitalizzare sul recente slancio rialzista, con molti che registrano aumenti fino al 40%. Di conseguenza, la capitalizzazione di mercato globale attuale delle criptovalute ha raggiunto 1,1 miliardi di dollari, un aumento di 200 milioni rispetto alla settimana precedente.</p>
<p>Alla luce di questo mix di sentimenti di mercato, la blockchain layer-2 molto attesa di Coinbase, Base, ha avuto un avvio difficile, con lamentele che emergono in tutto Internet. Su una nota simile, il CEO di Circle, Jeremy Allaire, si è schierato contro la proposta di regolamentazione delle stablecoin della SEC, suggerendo invece che un altro regolatore prenda il loro posto. Sul fronte istituzionale, la Colombia è diventata uno dei primi paesi a ospitare un’udienza completamente virtuale utilizzando il Metaverse di Meta.</p>
<p>Con questa serie di notizie, è probabile che nella prossima settimana si suscitino discussioni sulla regolamentazione, con regolatori e veterani del settore che si esprimono da entrambe le parti. Inoltre, è probabile che Coinbase inizi a prendere in considerazione le preoccupazioni degli utenti e si adatti per garantire la longevità della blockchain Base.</p>
<h2 id="h2-Ultime20notizie459237"><a name="Ultime notizie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultime notizie</h2><h3 id="h3-Il20Layer220di20Coinbase20ha20unimplementazione20complicata95845"><a name="Il Layer-2 di Coinbase ha un’implementazione complicata" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il Layer-2 di Coinbase ha un’implementazione complicata</h3><p>Il debutto della blockchain Layer-2 di Coinbase, Base, è stato molto atteso negli ultimi mesi, eppure il dispiegamento iniziale del testnet questa settimana si è rivelato relativamente burrascoso. Solo poche ore dopo il rilascio, la rete è stata soggetta a una serie di problemi, portando gli utenti a riversarsi sui social media per commentare sulla funzionalità della rete. Con problemi operativi, come transazioni non verificate e annullate, che affliggono la piattaforma, Coinbase ha rilasciato una dichiarazione ammettendo che questi problemi operativi erano dovuti a un problema con i loro portafogli interni che stimavano erroneamente il gas richiesto per eseguire le transazioni degli utenti.</p>
<p>Il <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il protocollo focalizzato si sforza di agire come un attore critico nella strategia di Coinbase per spostare il proprio modello di business verso lo spazio degli sviluppatori, poiché il traffico degli scambi e gli utili trimestrali hanno iniziato a diminuire nell’ultimo anno.</p>
<h3 id="h3-Il20CEO20di20Circle20si20schiera20contro20la20SEC20che20si20sta20muovendo20per20regolamentare20le20stablecoin442404"><a name="Il CEO di Circle si schiera contro la SEC che si sta muovendo per regolamentare le stablecoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il CEO di Circle si schiera contro la SEC che si sta muovendo per regolamentare le stablecoin</h3><p>Il CEO e fondatore di Circle, Jeremy Allaire, ha recentemente rilasciato una dichiarazione commentando il ruolo della SEC nella regolamentazione delle stablecoin. Allaire ha osservato che la SEC non è il ‘regolatore giusto’ per le stablecoin e che le attività di una stablecoin che facilita i pagamenti, come USDC, rientrano nella competenza di un regolatore bancario, anziché di un regolatore degli investimenti.</p>
<p>Allaire è stato rapidamente chiaro nel precisare che è ‘a favore’ della proposta della SEC di sottoporre le criptovalute ai requisiti di custodia qualificata e che non è contrario alla regolamentazione in generale. Allaire ha commentato: ‘Ci sono molte varietà, come ci piace dire, non tutte le stablecoin sono create uguali. Ma chiaramente, dal punto di vista delle politiche, il punto di vista uniforme nel mondo è che si tratta di un sistema di pagamento, di uno spazio di regolamentazione prudenziale.’ Le osservazioni di Allaire arrivano alla luce delle accuse di molti attori del settore secondo cui la SEC ‘sta superando i limiti della sua giurisdizione’ nel tentativo di intervenire nel più ampio mondo delle criptovalute.<br><img src="https://gimg2.gateimg.com/image/article/16772088191.png" alt=""><br>Jeremy Allaire (Immagine cortesia di Protocol)</p>
<h3 id="h3-La20Colombia20diventa20uno20dei20primi20paesi20ad20ospitare20unudienza20del20tribunale20Metaverse330437"><a name="La Colombia diventa uno dei primi paesi ad ospitare un’udienza del tribunale Metaverse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Colombia diventa uno dei primi paesi ad ospitare un’udienza del tribunale Metaverse</h3><p>La scorsa settimana, la Colombia è diventata uno dei primi paesi a sfruttare l’idea di Mark Zuckerberg, Meta, la capacità di ospitare incontri ufficiali e udienze. Le autorità giudiziarie in Colombia hanno utilizzato Horizon Workrooms, una piattaforma Meta che facilita la collaborazione tra team tramite spazi di lavoro virtuali, per ospitare un’udienza di due ore. L’udienza è stata trasmessa su YouTube, con tutti i partecipanti che utilizzavano visori virtuali per partecipare.</p>
<p>Come risultato dell’udienza, è stata presentata una denuncia che tenta di citare in giudizio la polizia, nonostante l’udienza sia stata nel complesso un successo. Tuttavia, la magistrata del tribunale di Magdalena, Maria Victoria Quinones Triana, ha dichiarato: ‘L’uso delle tecnologie dell’informazione nello sviluppo dei procedimenti giudiziari ha lo scopo essenziale di agevolare e accelerare questi processi [di esecuzione della giustizia]’; il che suggerisce che le udienze virtuali potrebbero diventare una pratica comune in Colombia nel prossimo futuro.<br><img src="https://gimg2.gateimg.com/image/article/16772088542.png" alt=""><br>Udienza del tribunale di Metaverse della Colombia (Immagine cortesia di Decrypt)</p>
<h2 id="h2-Tendenze20attuali20del20progetto978942"><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, il progetto che ha guadagnato di più nell’ultima settimana si è concentrato sullo script di programmazione Python. Bismuth, che ha visto un aumento di quasi il 420% solo nell’ultimo giorno, afferma di essere la prima piattaforma blockchain Python a facilitare l’utilità digitale su larga scala. Di conseguenza, ha attirato l’attenzione di diversi investitori ed è salito alle stelle da meno di $ 0,028 a $ 0,15.</p>
<h2 id="h2-Il20trend20attuale20del20BTC496845"><a name="Il trend attuale del BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il trend attuale del BTC</h2><p><img src="https://gimg2.gateimg.com/image/article/16772089023.png" alt=""><br>Settimanale <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">prezzo btc</a> Dati (Dati forniti da Blockchain.com)</p>
<p>Nell’arco della settimana scorsa, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è stato soggetto a un’enorme volatilità che lo ha portato a salire alle stelle da poco sotto la sua SMA a 7 giorni a $23.84k fino a un massimo settimanale di $25.15k. Da questo picco, BTC ha iniziato a scendere gradualmente attraverso la regione di $24k e nuovamente a scendere nei limiti superiori della regione di $23k prima di stabilizzarsi a $24k verso il 24. Nonostante questa performance mista, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> La performance di questa settimana è in linea con l’aumento trimestrale del prezzo che l’ha portato da $16,63k a $25k.</p>
<p>La traiettoria attuale del prezzo del BTC sembra indicare che continua a lottare contro la zona di resistenza di $25k e si allontana dalla regione di $20.000. Considerando che il BTC non si è discostato dalla tendenza progressiva al rialzo di questa settimana, è probabile che questa continui nella prossima settimana e potrebbe dargli l’opportunità di spingersi ulteriormente contro la zona di resistenza e potenzialmente stabilizzarsi nella zona di $25k.</p>
<p>Alla luce di questo, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> L’MVRV (valore di mercato al valore effettivo) di BTC ha continuato ad aumentare durante la scorsa settimana. Iniziata la settimana con un modesto 1,221, l’MVRV di BTC ha rapidamente iniziato a salire, raggiungendo il livello più alto del 2023, totalizzando 1,246 il 21. Questo indica che <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> sta avanzando ulteriormente nel territorio del valore di mercato effettivo e che c’è ancora spazio per crescere prima di entrare in territorio ipervenduto, il che significa che c’è il potenziale per superare la zona di $25k.<br><img src="https://gimg2.gateimg.com/image/article/16772089284.png" alt=""><br>Dati MVRV BTC a 12 giorni (Dati cortesia di Blockchain.com)</p>
<h2 id="h2-Lo20Stato20Delle20Gas20Fee20di20ETH966476"><a name="Lo Stato Delle Gas Fee di ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo Stato Delle Gas Fee di ETH</h2><p>Al 24 febbraio si è registrata una diminuzione moderata del volume totale di gas utilizzato nella scorsa settimana rispetto alla precedente, con il valore più alto raggiunto il 20, pari a 107.889.731.637. Il valore più basso raggiunto questa settimana è stato il 17, pari a 107.246.290.313, dimostrando un utilizzo totale simile a quello visto all’inizio del 2023. Questa diminuzione nella regione dei 107 miliardi è indicativa di una tendenza gradualmente decrescente dell’utilizzo di gas nell’ultimo mese.</p>
<p>Di conseguenza, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> I limiti delle commissioni di gas questa settimana hanno avuto un aumento moderato rispetto alla settimana precedente. I limiti bassi delle commissioni di gas erano compresi tra 15-145 gwei, i limiti medi erano compresi tra 15-782 gwei e i limiti alti erano compresi tra 15-1520 gwei - dimostrando una vasta disparità nelle commissioni di gas durante la scorsa settimana.</p>
<p>Nelle ultime 24 ore, i principali ‘Gas Guzzlers’ secondo Etherscan sono stati Blur.io: Marketplace (con commissioni totali di $556,149.45,756.45 o 337.35 ETH), 0xD4307E0acD12CF46fD6cf93BC264f5D5D1598792 (con commissioni totali di $512,265.46 o 310.73 ETH) e Seaport 1.1 (con commissioni totali di $385,899.76 o 234.08 ETH) - dimostrando così un aumento significativo rispetto alla settimana precedente.</p>
<p>Il costo stimato delle transazioni su piattaforme come OpenSea: Vendita, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> V3: Swap e USDT: Transfer, sono stati suggeriti essere tra $2.94 e $10.95, secondo Etherscan.</p>
<h2 id="h2-La20situazione20macro20attuale347237"><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-Citigroup20prevede20un20atterraggio20meno20duro20per20leconomia20globale20nel202023722589"><a name="Citigroup prevede un atterraggio “meno duro” per l’economia globale nel 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Citigroup prevede un atterraggio “meno duro” per l’economia globale nel 2023</h3><p>Mercoledì, gli economisti di Citigroup hanno iniziato a rivedere moderatamente al rialzo le loro previsioni di crescita globale, ipotizzando un ‘atterraggio’ meno duro per l’economia globale. Tuttavia, d’altro canto, gli economisti ritengono che l’economia mondiale crescerà al ritmo più lento degli ultimi 40 anni. La società di intermediazione ha suggerito che la crescita globale quest’anno rallenterà fino a circa il 2,2%, che è lo 0,25% in più rispetto alla loro precedente ipotesi.</p>
<h2 id="h2-Cosa20potrebbe20arrivare20nella20settimana20a20venire188088"><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 il mercato che mostra un sentimento misto questa settimana, è probabile che ciò continui nella settimana successiva, tuttavia, la traiettoria di valutazione sottostante per la maggior parte degli asset nei primi 100 sembra indicare un aumento lento e graduale, che fa pensare a un sentimento di mercato più positivo.</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 ripostare l'articolo a condizione che si faccia riferimento a Gate.io. In tutti gli altri casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>