V2lsbGVuIEJUQy1vbnR3aWtrZWxhYXJzICdpbnNjcmlwdGllcyB3dXJnZW4nPyBCZXN0YWFuIGpvdXcgJE9SREkgZW4gJFNBVFMgbmlldCBtZWVyPw==

2023-12-11, 02:26

<p><img src="https://gimg2.gateimg.com/image/article/17022611651690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR309"><a name="[TL;DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]</h2><p><a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Kernontwikkelaar Luke Dashjr plaatste op sociale media dat inies slechts een bug zijn en spamberichten naar de blockchain sturen.</p>
<p>De recente populariteit van BTC Inion assets geleid door $ORDI is zelf-evident, wat direct paniek veroorzaakte en leidde tot een snelle daling van de ORDI prijzen op 6 december. Iedereen is nieuwsgierig - zal wat Luke zei waarheid worden? Zal op een dag jouw $ORDI en $SATS plotseling verdwijnen?<br><img src="https://gimg2.gateimg.com/image/article/17022614001.png" alt=""><br>Bron: X</p>
<h2 id="h2-Introductie695615"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>In de afgelopen twee dagen is BTC gestegen, zelfs tot boven de $44000, dankzij positief nieuws zoals de voorspelling van de Federal Reserve van een renteverlaging en nieuws over nieuwe <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s. Het BTC-ecosysteem is een van de meest prominente sectoren. Echter, in het huidige tijdperk waarin de hele crypto-industrie sterk FOMO-gedreven wordt door de ORDI- en BRC20-tokens, heeft de verklaring van Luke Dashjr dat ‘het ordersprotocol en zijn derivaten kwetsbaarheden hebben uitgebuit, het is gewoon een scam’ bijna duizend… <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Golven</a>.</p>
<p>Luke heeft immers een speciale identiteit. Als ontwikkelaar van Bitcoin Core trad hij in 2011 toe tot de constructiewerkzaamheden van Bitcoin, wat hem natuurlijk een zeer invloedrijk type maakt in de ogen van veel spelers.</p>
<p>De trend van ORDI is nog dramatischer geworden, omdat het in het verleden is gestegen en de afgelopen twee dagen is gedaald; Het verhaal erachter lijkt echter niet zo eenvoudig te zijn.<br><img src="https://gimg2.gateimg.com/image/article/17022614212.png" alt=""><br>Bron: Gate.io</p>
<h2 id="h2-Waarom20is20de20Inschrijving20een20Bug554987"><a name="Waarom is de Inschrijving een Bug" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom is de Inschrijving een Bug</h2><p>Volgens Luke zelf bestonden ordinaals vanaf het begin niet, het was allemaal een scam. De kwetsbaarheid hier is de spam-aanval van ‘inschrijvingen’.</p>
<p>Oorspronkelijk hadden Bitcoin-blokken een limiet van 1M, maar het Ordinals-protocol sloeg bestandsgegevens op via taproot, waardoor NFT’s op elk apparaat werden gemaakt, waardoor Bitcoin-blokken gegevens konden laden die niet bedoeld waren.</p>
<p>Deze gegevens worden op de keten geplaatst in ‘Getuige’, en zowel blokken als transacties omzeilen de limiet van 1M. Op deze manier kan 4M worden gebruikt, en kan ook 400M worden gebruikt! Dit is geen innovatie, maar een aanval op kwetsbaarheden.<br><img src="https://gimg2.gateimg.com/image/article/17022614403.png" alt=""><br>Bron: unsplash</p>
<p>Het is niet moeilijk om te zien dat Luke, als de bouwer, een vastberaden houding heeft ten opzichte hiervan, en nog afgezien van de vraag of BRC20 een oplichterij is, is de methode van inschrijven inderdaad niet inheems voor BTC. Men kan zeggen dat dit een relatief slimme operatie is, en het voegt ook veel onnodige belasting toe aan het netwerk, wat een feit is. Op dit moment ontbreekt het BRC20-ecosysteem nog steeds aan infrastructuur en praktische toepassingen, en blijft hangen in de fase van meme hype marktsentiment.</p>
<p>Volgens de aard van blockchain staat alle gegevens op de ketting en moeten alle knooppunten worden gesynchroniseerd. Echter, te grote hoeveelheden gegevens kunnen leiden tot een hogere vork- en weesverhouding. ‘Bitcoin heeft geen slimme contracten, het is slechts een boekhoudkundig instrument dat alleen eigendomsoverdrachten registreert. Het is beknopt en heeft een redelijk energiemodel.’</p>
<p>De reeks activa afgeleid van het Ordinals-protocol lijken op ‘secundaire creaties’ op Bitcoin, maar ze hebben hun eigen beperkingen in het handelsproces: de logica van Ordinals is om tekst te ontleden en te sorteren, zonder een eendrachtige consensusrekenlaag; Transacties moeten worden voltooid via hangende orders; Wanneer er te veel operators zijn, veroorzaken de enorme gasvergoedingen onnodige verliezen voor andere spelers die het netwerk gebruiken, en verhogen ook de beveiligingsrisico’s van het netwerk.</p>
<h2 id="h2-Zal20BRC2020echt20verdwijnen20Waar20ligt20de20toestemmingsgrens20voor20ontwikkelaars312732"><a name="Zal BRC20 echt verdwijnen? Waar ligt de toestemmingsgrens voor ontwikkelaars?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zal BRC20 echt verdwijnen? Waar ligt de toestemmingsgrens voor ontwikkelaars?</h2><p>Dus de vraag die daarmee gepaard gaat, is heel duidelijk, kan Luke de inie echt laten verdwijnen?</p>
<p>Luke’s bijdrage staat buiten kijf. Momenteel behoort hij tot de top 11 bouwers in Bitcoin Core en zijn houding ten opzichte van Bitcoin is ook behoorlijk fundamentalistisch, wat zijn opmerkingen geloofwaardiger maakt.</p>
<p>Maar ten eerste is het Bitcoin-model een gedecentraliseerde allocatie, dus Luke noch het hele ontwikkelingsteam kan beslissen of ze een nieuw product willen behouden.</p>
<p>Bitcoin behoort niet toe aan één eigenaar, maar ontwikkelaars, miners en handelaren leggen de basis voor dit jonge en enorme bezit en vormen een complexe en uitgebreide bestuursgemeenschap. Simpel gezegd, als er echt belangrijke veranderingen zijn in de nieuwe versie, zijn er ook veel spelers die ervoor kunnen kiezen om de nieuwe versie niet te gebruiken.<br><img src="https://gimg2.gateimg.com/image/article/17022614924.png" alt=""><br>Bron: X</p>
<p>Ondertussen erkende Luke ook de vraag van netizens: “Kunnen we de Inion Chain gebruiken, zoals <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L2, als oplossing?” Bovendien heeft hij geen cognitieve aversie tegen creaties zoals inies en hij zei ook: “Het is niet nodig om alle inies te elimineren om nuttig te zijn in vergelijking met speciale munten.”</p>
<p>Dus voor nu is er geen reden om je inschrijving activa te laten verdwijnen. De belangen van mijnwerkers en handelaren zijn beide eisen van hoog niveau en niemand heeft het recht om ze op korte termijn te stoppen. Echter, het kan niet worden ontkend dat alles wat er met ORDI is gebeurd inderdaad koud water heeft gegoten op veel retail spelers, en heeft ons ook diep doen nadenken: kan het ‘inie verhaal’ dat marktoververhitting teweegbrengt maar gemakkelijk volatiel is door een enkele zin, blijven bestaan ​​voor een lange tijd?</p>
<h2 id="h2-Where20moeten20de20inschrijvingsactiva20en20het20BTCecosysteem20verdwijnen673664"><a name="Where moeten de inschrijvingsactiva en het BTC-ecosysteem verdwijnen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Where moeten de inschrijvingsactiva en het BTC-ecosysteem verdwijnen?</h2><p>Ethereum werd ooit een rijzende ster in de blockchain-wereld dankzij slimme contracten - niet langer alleen een grootboek dat wordt gebruikt om het eigendom van virtuele valuta vast te leggen, maar een plek waar applicaties kunnen worden opgezet, gedecentraliseerd bestuur kan worden geïmplementeerd, nieuwe vormen van financiën kunnen worden uitgevoerd en contentcreatie en sociale netwerken voor gaming kunnen worden gedaan.</p>
<p>Met de toename van netwerkbelasting en de opkomst van L2, bewegen oplossingen zoals roll up en zero knowledge proof, de gebruikerservaring geleidelijk naar WEB2.</p>
<p>Luke’s visie is niet om inies te verstikken of een BTC-ecosysteem te ontkennen dat inspiratie put uit het Ethereum-model, maar om bugs te repareren. Op dezelfde manier, als we het redelijk genoeg kunnen maken, dan is er geen reden om het bestaan van iets nieuws te ontkennen.</p>
<p>Zijn prestaties zijn echter niet zo zachtaardig, en veel spelers die bij ORDI blijven, zijn nog steeds van mening dat de technisch onderlegde man, vertegenwoordigd door Luke, net de goede kans heeft gemist om BRC20-auto’s te rijden, dus gebruiken ze deze schandelijke manier om de markt te beheersen en proberen ze zelf winst te maken - uiteraard is deze verklaring nog steeds een beetje extreem. De bezigheden van beide partijen, hoewel tegenstrijdig, zijn niet onverenigbaar.</p>
<p>Als er een oplossing is die vergelijkbaar is met L2, of als het off-chain berekeningen kan bundelen en alleen resultaten kan uploaden zonder de prestaties van de gehele BTC openbare keten in gevaar te brengen, kunnen de belangen van miners ook worden gegarandeerd en kan verder empowerment van BTC-toepassingsconstructie worden bereikt, lijkt het erop dat er geen mogelijkheid is om te stoppen. Op deze manier zullen meer spelers die hopen te investeren in langetermijnwaarde van valuta’s zoals ORDI ook toestromen.<br><img src="https://gimg2.gateimg.com/image/article/17022615045.png" alt=""><br>Bron: unsplash</p>
<p>Misschien is deze controverse een goed ‘blockchain sociaal experiment’. De technische factie vertegenwoordigd door Luke en de speculatieve factie die zwaar inzet op ORDI en SATS hebben niet helemaal gelijk. Degene die uiteindelijk een werkelijk redelijke oplossing voorstelt die de belangen van elke node kan waarborgen en tegelijkertijd het probleem van de netwerkbelasting kan oplossen, zal natuurlijk meer dan de helft van de goedkeuring ontvangen, zonder in conflict te komen met de fundamentalistische Bitcoin. Dit is geen eenvoudig proces, maar misschien is het wel de belichaming van de geest van decentralisatie.</p>
<p>Overigens is het interessant om op te merken dat hoewel BRC20-activa zoals ORDI zijn getroffen, inies die uitlopen op <a href="/price/solana-sol" target="_blank" class="blog_inner_link">SOLANA</a> en ETH lijken meer in trek te zijn. Zijn er delen die uw aandacht waard zijn? We hebben dit ook al eerder verkend, zie: <a href="https://www.gate.io/zh/blog_detail/3482/%E9%93%AD%E6%96%87%E8%B5%84%E4%BA%A7%E5%85%A8%E9%93%BE%E7%88%86%E5%8F%91-%E4%BB%8Ebrc20%E5%A4%96%E6%BA%A2%E5%88%B0solana%E5%92%8Cpolygon" target="_blank">https://www.gate.io/zh/blog_detail/3482/%E9%93%AD%E6%96%87%E8%B5%84%E4%BA%A7%E5%85%A8%E9%93%BE%E7%88%86%E5%8F%91-%E4%BB%8Ebrc20%E5%A4%96%E6%BA%A2%E5%88%B0solana%E5%92%8Cpolygon</a></p>
<p>De discussie tussen de twee partijen heeft geleid tot een verdamping op korte termijn van de marktwaarde van individuele tokens en een verlies van voordelen voor veel mensen. Het helpt echter om innovatie te stimuleren en nieuwe richtingen in Bitcoin en zelfs de hele cryptomarkt te brengen. Hoewel de resolute toon van Luke veel mensen een koud gevoel heeft gegeven, is aan de andere kant, in deze onlangs oververhitte en irrationele cryptomarkt, af en toe een koelvloeistof hebben niet per se een slechte zaak.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Sherry S.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<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 vermeld. In alle glen zal er juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>