V29uZGVyZW4gb2YgT3BsaWNodGluZywgQW5hbHlzZWVyIGRlIENvbnRyb3ZlcnNlIHZhbiBCaXRjb2luIEluc2NocmlqdmluZ2Vu

2023-12-15, 01:56

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR201993"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Onlangs, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Kernontwikkelaar Luke bekritiseerde de inie dat “spam” verboden moet worden, wat een breed debat in de gemeenschap heeft veroorzaakt.</p>
<p>Tegenstanders van Luke zijn doorgaans van mening dat het opkomen van inies een belangrijke innovatie is in het <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ecosysteem, en dat netwerkcongestie niet kan worden verlicht door inies te verbieden. Luke’s voorstel is te subjectief.</p>
<p>Beleggers dienen het verschil in marktvergelijking van tokeninies te begrijpen en tijdig passende investeringsbeslissingen te nemen met betrekking tot de frequente schommelingen van inies zoals ORDI.</p>
<h2 id="h2-Kennismaking608676"><a name="Kennismaking" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kennismaking</h2><p>Onlangs heeft Luke, de ontwikkelaar van Bitcoin Core, Inion bekritiseerd omdat het de kwetsbaarheden van Bitcoin gebruikt om spam op het Bitcoin-netwerk te plaatsen, en hij heeft verklaard dat Inion verboden moet worden. Deze verklaring heeft zich snel verspreid en heeft een breed debat in de Bitcoin gemeenschap veroorzaakt. Leiders van Inion zoals ORDI en SATS hebben ook vaak te maken gehad met grote meningsverschillen binnen de gemeenschap, wat heeft geleid tot grote schommelingen.</p>
<p>Het artikel zal een gedetailleerd overzicht van het evenement bieden en de lezers voorzien van een uitgebreide bespreking van de voor- en nadelen van de populaire inies in vergelijking met het Bitcoin-netwerk.</p>
<h2 id="h2-Luke20beschuldigt20Spam20van20het20filteren20van20ordinaalinies805365"><a name="Luke beschuldigt ‘Spam’ van het filteren van ordinaalinies" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Luke beschuldigt ‘Spam’ van het filteren van ordinaalinies</h2><p>Op 6 december uitten Bitcoin Core-ontwikkelaar Luke Dashjr zijn zorgen en kritiek op Twitter over de huidige populariteit van ordinaalinies.</p>
<p>Hij wees erop dat inies een kwetsbaarheid in de Bitcoin Core-client misbruiken om ‘spam’ naar de blockchain te sturen, wat binnenkort zal worden opgelost in zijn Bitcoin Knots V25.1.<img src="https://gimg2.gateimg.com/image/article/1702604988img_v3_0265_8ab0c379-a8f7-4d21-ade0-9884ab5542ix.jpg" alt=""><br>Bron: X@LukeDashjr</p>
<p>Luke wees erop dat de inie misbruik maakt van de kwetsbaarheid van Bitcoin om spamberichten naar het Bitcoin-netwerk te posten. Hij gelooft dat protocollen zoals Ordinals ‘waardeloos’ zijn, wat een ernstige invloed heeft op het normale gebruik van BTC als een peer-to-peer cryptocurrency.</p>
<p>Ondertussen stelde Luke een manier voor om inies te beperken door een beoordelingsmechanisme toe te voegen in de client om nodes te dwingen niet-standaard Taproot-transacties direct te verwijderen, en nodes vertragen dergelijke transacties niet langer om het doel van het verbieden van inies te bereiken.</p>
<p>Nadat dit standpunt naar voren werd gebracht, leidde dit onmiddellijk tot een aanhoudend debat in de gemeenschap. Hoewel Lukes opmerkingen slechts steun kregen van enkele OG’s zoals Samson Mow, Giacomo Zucco en William Casarin, nam hij toch het voortouw bij het nemen van maatregelen tegen ordinaalinies.</p>
<p>Er wordt gemeld dat Ocean Mine, opgericht door Luke Dashjr, is begonnen met het gebruik van de vaste versie van Bitcoin Knots om inietransacties te filteren. Een wereldwijde sales utive bij Ocean, die beweert Bitcoin Mechanical te zijn, zei zelfs: ‘Het heeft geen zin om censuur te bespreken met mensen die er niet bekend mee zijn. We zullen de inie rommel eruit filteren, en natuurlijk kun je vrijelijk mijnen in andere mijnen en FUD blijven verspreiden.’</p>
<p>Een minder opgemerkt stuk informatie is dat de Amerikaanse Nationale Kwetsbaarheidsdatabase (NVD) Bitcoin-inies op 9 december als een cybersecurity-risico heeft gemarkeerd, waarbij wordt opgeroepen tot aandacht voor beveiligingskwetsbaarheden in de ontwikkeling van het Ordinals Protocol in 2022. Deze database wordt beheerd door het Nationaal Instituut voor Normen en Technologie (NIST), een dochteronderneming van het Amerikaanse Ministerie van Handel.</p>
<h2 id="h2-Veel20mensen20zijn20optimistisch20over20het20Inionecosysteem20en20bekritiseren20Luke20omdat20hij20te20subjectief20is50504"><a name="Veel mensen zijn optimistisch over het Inion-ecosysteem en bekritiseren Luke omdat hij te subjectief is" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veel mensen zijn optimistisch over het Inion-ecosysteem en bekritiseren Luke omdat hij te subjectief is</h2><p>De marktvisie van Bitcoin-inies toont een duidelijke divergentie.</p>
<p>Enerzijds geloven leden die Luke ondersteunen dat de betekenis van de inie zelfs niet zo significant is en mogelijk zelfs een negatieve invloed kan hebben op de prijs van Bitcoin. De andere factie gelooft dat de opkomst van inies een belangrijke innovatie is in het Bitcoin-ecosysteem en dat netwerkcongestie niet kan worden verlicht door het verbieden van de handel in inies. Lukes voorstel is te subjectief.</p>
<p>Bijvoorbeeld, Miner vertegenwoordiger en F2pool oprichter Shenyu gaf in de gemeenschap aan dat BTC niet ETH is en de ontwikkelaars zeggen dat het niet uitmaakt. Als de ontwikkelaar erop staat om te upgraden, kan hij het zelf uitvorken. Maar op het kritieke moment van goedkeuring van Bitcoin spot ETF, is de mogelijkheid van het forken zeer laag.</p>
<p>Technologie-ontwikkelaar @jolestar tweette dat vanwege de populariteit van transacties veel mensen moeten communiceren met Bitcoin RPC, waardoor het aantal Bitcoin full nodes toeneemt. Hierdoor zijn meer gebruikers bezorgd over wat er in het grootboek staat en verbeteren transacties daadwerkelijk de beveiliging van Bitcoin-netwerken. De transactie is een ontdekking van de waarde van Bitcoin als een DA en heeft significante implicaties voor het Bitcoin-ecosysteem. Het is een functie, geen fout.<img src="https://gimg2.gateimg.com/image/article/1702605301img_v3_0265_5e5dc8a4-7ce2-4b61-8199-6676180092ix.jpg" alt=""><br>Bron: bitnodes.io</p>
<p>Ook de oprichter van SlowMist, Yu Xian, is van mening dat Luke’s standpunt te subjectief is en moeilijk te implementeren. Hij twitterde dat het standpunt van de kernontwikkelaar van Bitcoin hem heeft gestimuleerd en dat toekomstige versies van Bitcoin zullen herstellen wat hij beschouwt als een kwetsbaarheid: het serienummer/inie is een kwetsbaarheid van Bitcoin, een soort spam-aanval. In het begin was er discussie over deze kwesties en nu kan het een chirurgische ingreep zijn… Maar persoonlijk vind ik het niet nodig om dit te herstellen. Door de introductie van Taproot (een goede zaak) is het effect van per ongeluk openen van deze magische doos niet alleen een hoop spam, maar ook de activiteit van het Bitcoin-ecosysteem, dat niet alleen gaat over serienummer/inies.</p>
<p>Kortom, voorstanders van opschriften geloven over het algemeen dat opschriften zoals ordinale getallen het potentieel en de toekomst van Bitcoin vertegenwoordigen. Ondanks de recente populariteit van opschriften die netwerkcongestie veroorzaken, zijn er nog steeds veel oplossingen beschikbaar voor discussie en uitwisseling, en een ‘one size fits all’-benadering zoals Luke is niet voldoende.</p>
<h2 id="h2-Het20spel20is20nog20steeds20gaande20met20de20nadruk20op20gentensiveerde20prijsschommelingen773190"><a name="Het spel is nog steeds gaande, met de nadruk op geïntensiveerde prijsschommelingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het spel is nog steeds gaande, met de nadruk op geïntensiveerde prijsschommelingen</h2><p>In feite zijn meningsverschillen binnen de gemeenschap al lange tijd gebruikelijk in de geschiedenis van Bitcoin.</p>
<p>In de beginfase van de populariteit van inies in mei dit jaar, stelden Bitcoin Core-ontwikkelaars vraagtekens bij de inies en wezen ze in dev-e-mail op projecten die vergelijkbaar zijn met BRC-20 die enorme transactievolumes genereerden, en BTC-netwerken ondervonden ernstige congestie, waardoor het onmogelijk werd om ‘echte Bitcoin-transacties’ op de juiste manier te verpakken en te koppelen.</p>
<p>Als we nog verder teruggaan, zou Satoshi Nakamoto, de oprichter van Bitcoin, de eerste maker van de inie moeten zijn geweest, waarin informatie van The Times werd vastgelegd over de redding van banken in het oprichtingsblok.</p>
<p>De verklaring “the Times 03/Jan/2009 Chancellor on Brink of second bailout for banks” wordt ook beschouwd als een verklaring van de geboorte van Bitcoin, waarbij de teleurstelling van Satoshi Nakamoto over het traditionele financiële systeem en zijn idealen in vergelijking met Bitcoin wordt weerspiegeld.<img src="https://gimg2.gateimg.com/image/article/1702605339img_v3_0265_f65cc86c-2a57-4d51-b1f1-d259a58120ix.jpg" alt=""><br>Bron: Openbaar beeld</p>
<p>Natuurlijk is het niet alleen Satoshi Nakamoto, de oprichter, die waardevolle informatie in het Bitcoin-netwerk heeft gebracht. In feite zijn er tot nu toe meer dan 33 miljoen inschrijvingen gemaakt en overgedragen, maar de netwerkcongestie veroorzaakt door de handel in inschrijvingen kan ook onverwacht zijn.</p>
<p>Deze gemeenschapsdiscrepantie is echter niet onoplosbaar. Het Ordinals Inion Protocol is een off-chain consensusprotocol en zolang de indexer en de gemeenschap tot een consensus komen, kunnen er eigenlijk veel oplossingen zijn. Het meest ‘halal’ Lightning Network heeft onlangs een efficiëntere en kosteneffectieve inieoplossing geprobeerd, genaamd NostrAssets. Dashjr heeft ook onlangs zijn scherpe houding verzacht en verklaard dat ‘we voordelen kunnen brengen aan het Bitcoin-ecosysteem zonder alle inies te elimineren’.</p>
<p>Voor investeerders zal de huidige situatie van gefragmenteerd consensus dat nog niet is overbrugd ongetwijfeld een reeks frequente hoge schommelingen in inies en tokens veroorzaken, wat zeer verontrustend is.</p>
<p>Na de aankondiging van Luke op 6 december dat hij het Taproot-lek zou repareren en Bitcoin-inies zou verbieden, daalde de prijs van de BRC20-tokenleider ORDI met meer dan 20% van $65. Met de opkomst van meer publieke opinie die het inies-ecosysteem ondersteunt, is het bullish sentiment hersteld en heeft ORDI een nieuw hoogtepunt bereikt. Later, toen Bitcoin op de 11e een kortetermijn sterke daling doormaakte, werden ORDI en andere tokens ook passief verlaagd, en de volatiliteit van het hoogwaardige ORDI was aanzienlijk hoger dan die van andere sector tokens.<img src="https://gimg2.gateimg.com/image/article/1702605370img_v3_0265_fd6277e9-3722-4182-bf8d-7d4d8b8df9ix.jpg" alt=""><br>Bron: Gate.io</p>
<p>Over het algemeen is de divergentie tussen de markt en de inies op speciale munten een complex en belangrijk probleem. Het omvat meerdere aspecten zoals de prestaties, beveiliging en toekomstige ontwikkeling van Bitcoin. Ondertussen is het voor de Bitcoin-gemeenschap een uitdaging om de belangen van alle partijen in evenwicht te brengen en de stabiliteit en ontwikkeling van de gemeenschap te handhaven. Voor investeerders is het cruciaal om de verschillen op de markt te begrijpen in vergelijking met de inies op Bitcoin en tijdig bijbehorende investeringsbeslissingen te nemen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt genoemd. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>