SGVyb3ZlcndlZ2luZyBhY2h0ZXIgZGUgZ2VrdGU6IDggTWlzdmF0dGluZ2VuIG92ZXIgSW5zY2hyaWp2aW5nc2RlYmF0dGVu

2024-01-10, 08:24

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR743462"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>De ontwikkeling van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Inies groeit en ons begrip ervan heeft ook dynamische correctie nodig om te voorkomen dat we in verschillende cognitieve valkuilen vallen.</p>
<p>“Carven” op <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> is noch de nieuwste vorm van token distributie, noch pure MEME-hype, maar eigenlijk een unieke Renaissance in de cryptografie industrie.</p>
<p>De gekte rond Bitcoin inies betekent niet noodzakelijkerwijs een voortdurende of ononderbroken groei. Investeren in inies moet binnen iemands mogelijkheden liggen en wat belangrijk is, is DYOR.</p>
<h2 id="h2-Inleiding652554"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Bij de verkenning van de cryptodigitale wereld komen voortdurend nieuwe dingen naar voren, vergezeld van veel controverses en innovaties, en inies die sinds vorig jaar populair zijn, zijn ook onvermijdelijk.</p>
<p>In feite hebben we meerdere keren inies besproken in onze blog, maar over het algemeen moeten de opvattingen van iedereen over nieuwe dingen dynamisch worden aangepast. Dit is als een blinde die een olifant aanraakt, en elk van ons kan in het begin misschien alleen de top van een ijsberg aanraken.</p>
<p>In de afgelopen zes maanden hebben we verschillende perspectieven en interpretaties gezien die werden veroorzaakt door het nieuwe veld van inies, alsof iedereen alleen maar een poot of een lange neus van een olifant aanraakte.</p>
<p>Maar naarmate het jaar 2024 nadert, is de populariteit van inies eindelijk begonnen af te nemen. We kunnen ook de vele veranderingen die inies en hun infrastructuur met zich hebben meegebracht voor de cryptomarkt opnieuw bekijken, en we kunnen een duidelijker en meer omvattend begrip krijgen van veel misvattingen of meningsverschillen.</p>
<h2 id="h2-Misvatting20120Inschrijving20is20een20nieuwe20methode20voor20tokenverdeling514535"><a name="Misvatting 1: Inschrijving is een nieuwe methode voor tokenverdeling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Misvatting 1: Inschrijving is een nieuwe methode voor tokenverdeling</h2><p>Sommige mensen zien inies als een nieuwe manier om tokens te verspreiden, maar deze perceptie is eigenlijk een misvatting. In feite bestaat het concept van ‘inschrijven’ al in het blockchain-veld en bieden sommige mining pools zelfs gerelateerde graveerdiensten aan.</p>
<p>Al in 2011 maakten kunstenaars gebruik van de kenmerken van Bitcoin-handel om tekst om te zetten in ASCII-kunstvormen en deze aan transactiegegevens te koppelen, die permanent op de blockchain werden bewaard.</p>
<p>Een van de werken brengt eerbetoon aan de overleden vroege Bitcoin ontwikkelaar Len Sassaman en toenmalig voorzitter van de Federal Reserve Ben Bernanke, maar deze digitale kunstwerken kunnen niet worden bezeten en verhandeld, dus ze werden niet populair in het Bitcoin ecosysteem.<br><img src="https://gimg2.gateimg.com/image/article/1704875185img_v3_026v_5c3377ff-9edd-48dc-bcc1-0deddc0d3cix.jpg" alt=""><br>Bron: openbare gegevens</p>
<p>Na blockchain-netwerken zoals <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Nu NFT’s naar het grote publiek worden geduwd, is er de laatste tijd geleidelijk aan een ‘beeldhouwwerk’ op Bitcoin ontstaan, wat eigenlijk als een Renaissance kan worden beschouwd.</p>
<h2 id="h2-Misvatting20220Inion20is20een20kortstondige20hype20van20MEME20Capital861661"><a name="Misvatting 2: Inion is een kortstondige hype van MEME Capital" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Misvatting 2: Inion is een kortstondige hype van MEME Capital</h2><p>Veel mensen zien inies als een kortetermijnhype-tool voor MEME-kapitaal, en dit standpunt vangt inderdaad een deel van de waarheid over de cyclische schommelingen van web3.</p>
<p>Maar wat we ook moeten zien is dat veel inie tokens zijn weggegaan van de vroege pure MEME vorm en zijn versterkt met meer crypto glen, zoals TURT, MUBI, RDEX en vele andere tokens die worden gebruikt als protocol tokens voor het BRC20-project.</p>
<h2 id="h2-Misvatting20320Inschrijving20is20een20historische20regressie436696"><a name="Misvatting 3: Inschrijving is een historische regressie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Misvatting 3: Inschrijving is een historische regressie</h2><p>Sommige mensen geloven dat inies verouderde technologie zijn, maar in feite is dit ook een misvatting. Voor Bitcoin-mainchains zonder slimme contracten is de uitgifte van inies inderdaad vereist het gebruik van varianten van BRC-20 of vergelijkbare protocollen.</p>
<p>Voor slimme contract openbare ketens is het uitgeven van inies in de vorm van inies inderdaad een technologische tegenslag.</p>
<p>Maar dat betekent niet dat inie verouderde technologie is, technologie wordt immers gebruikt om de gemeenschap te dienen, en de populariteit van inie heeft inderdaad het ontwikkelingspotentieel van het ecosysteem van Bitcoin, een grote goudmijn, gestimuleerd.</p>
<p>En zoals we hierboven al vermeldden, is het inschrijven van tekst op de Bitcoin-keten niets nieuws, het was destijds beperkt tot de aanzienlijke voorwaarden. Deze poging was slechts oppervlakkig en nu hebben de nieuwe omstandigheden deze operatie weer aangewakkerd.</p>
<p>Dus in plaats van te zeggen dat het een regressie is, is het meer een beweging zoals de Renaissance.</p>
<h2 id="h2-Misvatting20420Inschrijving20is20hetzelfde20als20NFT176094"><a name="Misvatting 4: Inschrijving is hetzelfde als NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Misvatting 4: Inschrijving is hetzelfde als NFT</h2><p>Inies en NFT’s zijn twee verschillende vormen van digitale activa die op verschillende vlakken aanzienlijk van elkaar verschillen.</p>
<p>Ten eerste is Bitcoin Inion een technologie gebaseerd op de Bitcoin blockchain die informatie in Bitcoin-transacties verwerkt en deze op de blockchain registreert. NFT’s daarentegen zijn digitale activa gebaseerd op blockchain-netwerken zoals Ethereum, die unieke digitale inhoud of waarde vertegenwoordigen.</p>
<p>Ten tweede is het kenmerk van Bitcoin-inies dat ze volledig on-chain zijn en informatie direct in de blockchain wordt geschreven. NFT daarentegen bereikt de uniciteit en het bewijs van eigendom van digitale activa door middel van slimme contracten.</p>
<p>Bitcoin-inie is een type inie dat kan worden begrepen als een fysieke vorm van informatie gegraveerd op de Bitcoin blockchain. NFT daarentegen is een virtueel digitaal bezit waarvan de waarde afhangt van de uniekheid en schaarste van digitale inhoud.</p>
<p>Uiteindelijk kunnen Bitcoin inies doorgaans geen open blind box-effect bereiken en zijn ze statisch, terwijl NFT’s dynamische proof-of-stake- en handelsmechanismen kunnen bereiken via slimme contracten.<img src="https://gimg2.gateimg.com/image/article/1704875239img_v3_026v_e5bf545d-707e-4193-a4b0-57736725d9ix.jpg" alt=""><br>Bron: cryptotimes.io</p>
<p>Over het algemeen zijn er verschillen tussen Bitcoin-inies en NFT’s op het gebied van technische fundamenten, toepassingsscenario’s en kenmerken, maar beide hebben unieke identificatie en bewijs van eigendom, die een bepaald actief of waarde kunnen vertegenwoordigen.</p>
<h2 id="h2-Misvatting20520Inschrijving20is20een20kwetsbaarheid20die20de20decentralisatie20van20het20Bitcoinnetwerk20ondermijnt749275"><a name="Misvatting 5: Inschrijving is een kwetsbaarheid die de decentralisatie van het Bitcoin-netwerk ondermijnt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Misvatting 5: Inschrijving is een kwetsbaarheid die de decentralisatie van het Bitcoin-netwerk ondermijnt</h2><p>Critici betogen dat de inie de kenmerken van het OP_IF-blok en de OP_PUSH-operator gebruikt om gegevens te vermommen als Bitcoin-programmagegevens, en zo de beperking van de gegevensdragersgrootte te omzeilen. De inie maakt geen gebruik van OP_RETURN, zonder beperkt te worden door gegevensdragersgrootte, wat betekent dat node-operators en miners een zekere mate van controle hebben over de totale omvang van de gegevens die ze willen doorgeven en in het blok willen opnemen.</p>
<p>De inie maakt ook slim gebruik van de functies van segwit v1 (getuige korting) en v2/taprot (geen willekeurige  grootte limiet). Het moet worden opgemerkt dat Bitcoin oorspronkelijk niet bedoeld was voor het opslaan van gegevens, dus elke benadering die Bitcoin gemakkelijk maakt om gegevens door te geven, moet worden beschouwd als een potentieel probleem.</p>
<p>Bitcoin kernontwikkelaar Luke’s Bitcoin Knots bood enkele opties om deze zogenaamde junkgegevens te bestrijden, maar op 8 januari werd het Github-voorstel van Luke Dashjr om inies te beperken verworpen.<br><img src="https://gimg2.gateimg.com/image/article/1704875271img_v3_026v_2f9f5fed-ee5b-4313-99da-3aec1b8402ix.jpg" alt=""><br>Bron: github</p>
<h2 id="h2-Misvatting20620Inschrijving20is20een20tegenaanval20van20het20BTCecosysteem20tegen20het20ETHecosysteem932618"><a name="Misvatting 6: Inschrijving is een tegenaanval van het BTC-ecosysteem tegen het ETH-ecosysteem" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Misvatting 6: Inschrijving is een tegenaanval van het BTC-ecosysteem tegen het ETH-ecosysteem</h2><p>De BRC-20-protocoltoken van het BTC-ecosysteem is populairder onder particuliere beleggers in vergelijking met verschillende NFT’s in de vorige bullmarkt, omdat eerlijkheid en het recht om te slaan worden nagestreefd. Deze eerlijke en open tokenuitgiftemethode is meer in lijn met de geest van decentralisatie dan de privéprijsstelling van NFT’s door instellingen. Dit kan worden gezien als een weerstand tegen het door VC en instellingen geleide Ethereum-ecosysteem.</p>
<p>Met andere woorden, dit is vooruitgang in plaats van een tegenaanval.</p>
<h2 id="h2-Misvatting20720Als20Bitcoin20Core20besluit20de20handel20in20inies20te20verbieden20zullen20de20inies20volledig20niet20verhandelbaar20zijn213403"><a name="Misvatting 7: Als Bitcoin Core besluit de handel in inies te verbieden, zullen de inies volledig niet verhandelbaar zijn." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Misvatting 7: Als Bitcoin Core besluit de handel in inies te verbieden, zullen de inies volledig niet verhandelbaar zijn.</h2><p>Het antwoord is niet zo absoluut.</p>
<p>Gezien de diversiteit van Bitcoin Core clients, met name degenen die nog steeds oudere versies gebruiken, zal de handelskracht van inies niet onmiddellijk verdwijnen. Momenteel zijn er ongeveer 17000 Bitcoin Core clients in gebruik, waarvan 9000 versies 24-25 zijn en de andere 5000 versies 21-23. Dit betekent dat zelfs met de toevoeging van regels die het misbruik van blockspace in versie 27 verbieden, de oude versie nog steeds goed kan functioneren.</p>
<p>Daarom kunnen de inies nog steeds hun handelsactiviteiten voortzetten zolang je geduldig bent en wacht tot de oude versie van de Core blokkeert. Natuurlijk hebben mijnwerkers de neiging om te upgraden naar de nieuwste versie. Als iedereen geleidelijk in de loop van de tijd upgrade, kan de bruikbaarheid van de inies ernstig worden beïnvloed.</p>
<p>Kortom, of inies al dan niet kunnen blijven worden verhandeld, hangt grotendeels af van de vraag of miners en node-operators bereid zijn om oudere versies van de client te blijven ondersteunen. Als de meeste mensen ervoor kiezen om te upgraden naar een nieuwe versie, kan de toekomst van de inies onzeker worden.</p>
<h2 id="h2-Misvatting20820Inschrijving20is20een20innovatieve20vorm20die20het20middelpunt20zal20worden20van20waardebeleggingen20in20deze20bullmarkt23853"><a name="Misvatting 8: Inschrijving is een innovatieve vorm die het middelpunt zal worden van waardebeleggingen in deze bullmarkt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Misvatting 8: Inschrijving is een innovatieve vorm die het middelpunt zal worden van waardebeleggingen in deze bullmarkt</h2><p>Innovatie betekent niet continu groei, en wanneer het ecosysteem te welvarend is, kan het ook diepe aanpassingen ondergaan. Wat belangrijk is, is DYOR, in plaats van FOMO of FUD die investeringsbeslissingen drijft, wat niet alleen van toepassing is op het gebied van inies, maar ook op andere sectoren.</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 standpunten van de onderzoeker en vormt geen enkele beleggingssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt genoemd. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>