TWlyYWNvbGkgbyB0cnVmZmUsIGFuYWxpenphcmUgbGEgY29udHJvdmVyc2lhIGRlbGxlIGlzY3JpemlvbmkgQml0Y29pbg==

2023-12-15, 01:56

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR719876"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Recentemente <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Alessio</a> Il developer principale Luke ha criticato l’iscrizione secondo cui è necessario vietare lo “spam”, cosa che ha scatenato un ampio dibattito nella comunità.</p>
<p>Gli avversari di Luke credono generalmente che l’emergere delle iscrizioni sia un’innovazione significativa nell’ecosistema di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> e che la congestione della rete non possa essere alleviata vietando le iscrizioni. La proposta di Luke è troppo soggettiva.</p>
<p>Gli investitori dovrebbero comprendere le differenze nel confronto di mercato delle iscrizioni dei token e prendere tempestivamente decisioni di investimento corrispondenti riguardo alle frequenti fluttuazioni delle iscrizioni come ORDI.</p>
<h2 id="h2-Introduzione899094"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Di recente, Luke, lo sviluppatore di Bitcoin Core, ha criticato Inion per aver utilizzato le vulnerabilità di Bitcoin per pubblicare spam sulla rete Bitcoin, affermando che Inion dovrebbe essere bandito. Questa affermazione si è diffusa rapidamente e ha suscitato un ampio dibattito nella comunità Bitcoin, e anche i leader di Inion come ORDI e SATS hanno subito frequenti fluttuazioni a causa di enormi disaccordi nella comunità.</p>
<p>L’articolo fornirà una panoramica dettagliata dell’evento e fornirà ai lettori una discussione dettagliata dei vantaggi e svantaggi delle iscrizioni popolari rispetto alla rete Bitcoin.</p>
<h2 id="h2-Luke20accusa20lo20spam20di20filtrare20le20iscrizioni20ordinali91073"><a name="Luke accusa lo “spam” di filtrare le iscrizioni ordinali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Luke accusa lo “spam” di filtrare le iscrizioni ordinali</h2><p>Il 6 dicembre, lo sviluppatore di Bitcoin Core Luke Dashjr ha espresso le sue preoccupazioni e critiche su Twitter riguardo alla popolarità attuale delle iscrizioni ordinali.</p>
<p>Ha sottolineato che le iscrizioni stanno sfruttando una vulnerabilità nel client Bitcoin Core per inviare “spam” alla blockchain, che verrà presto risolta nella sua versione Bitcoin Knots V25.1.<img src="https://gimg2.gateimg.com/image/article/1702604988img_v3_0265_8ab0c379-a8f7-4d21-ade0-9884ab5542ix.jpg" alt=""><br>Fonte: X@LukeDashjr</p>
<p>Luke ha sottolineato che l’iscrizione sta sfruttando la vulnerabilità di Bitcoin per inviare messaggi di spam alla rete Bitcoin. Egli ritiene che protocolli come Ordinals siano “inutili”, il che influisce seriamente sull’uso normale del BTC come criptovaluta peer-to-peer.</p>
<p>Nel frattempo, Luke ha proposto un modo per limitare le iscrizioni aggiungendo un meccanismo di revisione nel client per forzare i nodi a eliminare direttamente le transazioni Taproot non standard e i nodi non ritardano più tali transazioni per raggiungere l’obiettivo di vietare le iscrizioni.</p>
<p>Una volta avanzato questo punto di vista, ha immediatamente suscitato un dibattito sostenuto nella comunità. Nonostante le osservazioni di Luke abbiano ricevuto il sostegno solo di alcuni OG come Samson Mow, Giacomo Zucco e William Casarin, ha comunque preso il comando nel prendere provvedimenti contro le iscrizioni ordinali.</p>
<p>Si riporta che Ocean Mine, fondata da Luke Dashjr, ha iniziato ad utilizzare la versione stabile di Bitcoin Knots per filtrare le transazioni di iscrizione. Un dirigente vendite globale presso Ocean, che sostiene di essere Bitcoin Mechanical, ha persino detto: “è inutile discutere di censura con persone che non ne sono familiari. Filtreremo la spazzatura di iscrizione e naturalmente potrete continuare a estrarre liberamente in altre miniere e a diffondere FUD.”</p>
<p>Un’altra informazione meno notata è che il database nazionale delle vulnerabilità degli Stati Uniti (NVD) ha segnalato le iscrizioni di Bitcoin come un rischio per la sicurezza informatica il 9 dicembre, chiedendo attenzione alle vulnerabilità di sicurezza nello sviluppo del Protocollo delle Ordinali nel 2022. Questo database è gestito dal National Institute of Standards and Technology (NIST), una sussidiaria del dipartimento del Commercio degli Stati Uniti.</p>
<h2 id="h2-Molte20persone20sono20ottimistiche20riguardo20allecosistema20di20iscrizione20e20criticano20Luke20per20essere20troppo20soggettivo832594"><a name="Molte persone sono ottimistiche riguardo all’ecosistema di iscrizione e criticano Luke per essere troppo soggettivo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Molte persone sono ottimistiche riguardo all’ecosistema di iscrizione e criticano Luke per essere troppo soggettivo</h2><p>La visione di mercato delle iscrizioni Bitcoin mostra una chiara divergenza.</p>
<p>Da un lato, i membri che sostengono Luke credono che il significato dell’iscrizione non sia nemmeno così significativo e possa persino avere un impatto negativo sul prezzo del Bitcoin. L’altra fazione ritiene che l’emergere delle iscrizioni sia un’innovazione significativa nell’ecosistema Bitcoin e che la congestione della rete non possa essere alleviata vietando il trading di iscrizioni. La proposta di Luca è troppo soggettiva.</p>
<p>Ad esempio, il rappresentante di Miner e fondatore di F2pool, Shenyu, ha espresso in comunità che BTC non è ETH, e gli sviluppatori dicono che non importa. Se lo sviluppatore insiste nell’aggiornamento, allora può farlo da solo. Ma nel momento critico dell’approvazione dell’ETF Bitcoin spot, la possibilità di una divisione è molto bassa.</p>
<p>Lo sviluppatore di tecnologia @jolestar ha twittato che a causa della popolarità delle iscrizioni, molte persone hanno bisogno di interagire con Bitcoin RPC, aumentando il numero di nodi completi di Bitcoin. In questo modo, più utenti sono preoccupati per ciò che è registrato nel registro, e le iscrizioni migliorano effettivamente la sicurezza delle reti Bitcoin. L’iscrizione è una scoperta del valore di Bitcoin come DA e ha implicazioni significative per l’ecosistema Bitcoin. È una caratteristica piuttosto che un difetto.<img src="https://gimg2.gateimg.com/image/article/1702605301img_v3_0265_5e5dc8a4-7ce2-4b61-8199-6676180092ix.jpg" alt=""><br>Origine: bitnodes.io</p>
<p>Anche il fondatore di SlowMist, Yu Xian, ritiene che il punto di vista di Luke sia troppo soggettivo e difficile da implementare. Ha twittato affermando che il punto di vista dello sviluppatore principale di Bitcoin lo ha stimolato e se tutto va come lui desidera, le future versioni di Bitcoin risolveranno ciò che lui ritiene una vulnerabilità: il numero di serie/l’iscrizione è una vulnerabilità di Bitcoin, un tipo di attacco spam. All’inizio c’è stato un dibattito su questi argomenti e ora potrebbe essere necessario un intervento chirurgico… ma personalmente, ritengo che non sia necessario risolvere questo problema. Grazie all’introduzione di Taproot (una cosa positiva), l’impatto dell’apertura accidentale di questa scatola magica non è solo una serie di spam, ma anche l’attività dell’ecosistema Bitcoin, che non riguarda solo i numeri di serie/iscrizioni.</p>
<p>In sintesi, i sostenitori delle iscrizioni generalmente ritengono che iscrizioni come gli ordinali rappresentino il potenziale e il futuro di Bitcoin. Nonostante la recente popolarità delle iscrizioni che causano congestione di rete, ci sono ancora molte soluzioni disponibili per la discussione e lo scambio, e un approccio universale come Luke non è sufficiente.</p>
<h2 id="h2-Il20gioco2020ancora20in20corso20concentrandosi20su20fluttuazioni20di20prezzo20intensificate23854"><a name="Il gioco è ancora in corso, concentrandosi su fluttuazioni di prezzo intensificate" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il gioco è ancora in corso, concentrandosi su fluttuazioni di prezzo intensificate</h2><p>In realtà, i disaccordi nella comunità sono stati comuni lungo tutta la storia del Bitcoin.</p>
<p>Nelle prime fasi della popolarità delle iscrizioni a maggio di quest’anno, gli sviluppatori di Bitcoin Core hanno messo in discussione le iscrizioni e hanno evidenziato in una e-mail di sviluppo che i progetti simili a BRC-20 hanno generato enormi volumi di transazioni e le reti BTC hanno subito gravi congestioni, con conseguente incapacità di confezionare e collegare correttamente le ‘vere transazioni Bitcoin’.</p>
<p>Se risaliamo ancora più indietro, Satoshi Nakamoto, il fondatore di Bitcoin, dovrebbe essere stato il primo creatore dell’iscrizione, registrando le informazioni dal The Times sul salvataggio delle banche da parte del governo nel blocco fondatore.</p>
<p>La dichiarazione “the Times 03/Jan/2009 Cancelliere sull’orlo del secondo salvataggio per le banche” è considerata anche una dichiarazione della nascita di Bitcoin, riflettendo la delusione di Satoshi Nakamoto nei confronti del sistema finanziario tradizionale e dei suoi ideali in confronto a Bitcoin.<img src="https://gimg2.gateimg.com/image/article/1702605339img_v3_0265_f65cc86c-2a57-4d51-b1f1-d259a58120ix.jpg" alt=""><br>Origine: Immagine pubblica</p>
<p>Naturalmente, non è solo Satoshi Nakamoto, il fondatore, a portare informazioni di valore importanti nella rete Bitcoin. Infatti, finora sono state create e trasferite più di 33 milioni di iscrizioni, ma la congestione di rete causata dal commercio di iscrizioni potrebbe essere anche imprevista.</p>
<p>Tuttavia, questa divergenza nella comunità non è senza soluzione. Il Protocollo di Iscrizione degli Ordinali è un protocollo di consenso off chain e, fintanto che l’indicizzatore e la comunità raggiungono un consenso, possono effettivamente esserci molte soluzioni. La rete “halal” più efficiente ed economica ha recentemente provato una soluzione di iscrizione più efficiente e conveniente, NostrAssets. Dashjr ha anche recentemente attenuato la sua posizione decisa, affermando che “possiamo apportare benefici all’ecosistema Bitcoin senza eliminare tutte le iscrizioni.”</p>
<p>Naturalmente, per gli investitori, la situazione attuale del consenso frammentato che ancora non è stato colmato scatenerà una serie di frequenti e alte fluttuazioni nelle iscrizioni e nei token, il che è molto preoccupante.</p>
<p>Dopo che Luke ha annunciato il 6 dicembre che avrebbe risolto la vulnerabilità di Taproot e vietato le iscrizioni Bitcoin, il prezzo del leader del token BRC20 ORDI è sceso di più del 20% dai $65. Con l’ulteriore emergere di opinioni pubbliche a sostegno dell’ecosistema delle iscrizioni, il sentiment rialzista è stato riparato e ha spinto ORDI a raggiungere un nuovo massimo. Successivamente, con il brusco declino a breve termine di Bitcoin l’11, ORDI e altri token sono stati anch’essi passivamente abbassati, e la volatilità dell’ORDI di alto livello è stata significativamente più alta rispetto a quella degli altri token del settore.<img src="https://gimg2.gateimg.com/image/article/1702605370img_v3_0265_fd6277e9-3722-4182-bf8d-7d4d8b8df9ix.jpg" alt=""><br>Sorgente: Gate.io</p>
<p>In generale, la divergenza tra il mercato e le iscrizioni sulle monete speciali è una questione complessa e importante. Coinvolge molteplici aspetti come la performance, la sicurezza e lo sviluppo futuro di Bitcoin. Nel frattempo, per la comunità Bitcoin, bilanciare gli interessi di tutte le parti e mantenere la stabilità e lo sviluppo della comunità è anche un compito impegnativo. Per gli investitori, è fondamentale comprendere le differenze presenti nel mercato rispetto alle iscrizioni su Bitcoin e prendere tempestivamente decisioni di investimento corrispondenti.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>