5omTIiBCaXRjb2luLWluc2NyaXB0aWUsIHdhdCBiZXRla2VudCAi5omTIiBwcmVjaWVzPw==

2024-01-30, 02:52

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR78438"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>‘Inie’ is een metaforische uitdrukking die verwijst naar het permanent vastleggen van bepaalde informatie op de Bitcoin-blockchain.</p>
<p>“Inschrijving graveren” verwijst naar het gebruik van de “op_return” functie om specifieke informatie te creëren of in te sluiten in een <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> transactie;</p>
<p>De gegraveerde informatie wordt permanent vastgelegd en kan door iedereen worden bekeken, maar kan niet worden gewijzigd of verwijderd;</p>
<p>‘打’ inie is een handeling vol kunstzinnigheid en technische bekwaamheid, waarbij persoonlijke wil en digitale wereld voor altijd samenkomen.</p>
<h2 id="h2-Inleiding6833"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>In de wereld van blockchain is ‘hashen’ van bitcoin-inies een professioneel en mysterieus concept. Het verschilt van traditionele financiële transacties en lijkt meer op een artistieke technische expressie. Nu wordt het in verband gebracht met top blockchain-termen zoals minen, handelen en slimme contracten, en vormt het de basis van de bitcoin-wereld.</p>
<p>Dit artikel zal de diepere betekenis achter deze handeling onthullen en op een begrijpelijke manier uitleggen wat inies zijn en waarom we inies ‘slaan’. Laten we samen de unieke en verfijnde technologie in dit blockchain-domein verkennen.</p>
<h2 id="h2-Wat20is20een20inie307587"><a name="Wat is een inie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een inie?</h2><p>In the context of the Bitcoin blockchain, ‘inions’ (Inions) is a metaphorical expression that refers to permanently recording certain information on the Bitcoin blockchain. This process can be understood as leaving annotations or remarks on an immutable digital ledger. These pieces of information do not participate in the transfer of Bitcoin’s transaction value, but they can exist as evidence, statements, or any other records that need to be permanently preserved.</p>
<p>Stel je voor, het is als het graveren van woorden op een oude steen, eenmaal gegraveerd, blijven de woorden voor altijd tenzij de steen wordt vernietigd. In blockchain is ‘inie’ vergelijkbaar met het graveren van woorden op een digitaal stenen monument, de informatie die op de Bitcoin blockchain is gegraveerd, wordt permanent bewaard en kan door iedereen worden bekeken, maar kan niet worden gewijzigd of verwijderd.<br><img src="https://gimg2.gateimg.com/image/article/1706583029img_v3_027j_4d6afd9c-5f46-466a-b881-5d5b46ee8cix.jpg" alt=""></p>
<h2 id="h2-Waarom20is20het20inieslaan826387"><a name="Waarom is het inieslaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom is het inieslaan?</h2><p>In het Chinees kan het woord ‘打铭文’ afgeleid zijn van de ‘op_return’-functie van Bitcoin-transacties. ‘打’ is hier meestal een werkwoord dat de acties ‘graveren’ of ‘creëren’ betekent. Daarom betekent ‘打铭文’ in de context van de Bitcoin-blockchain eenvoudigweg het creëren of insluiten van een specifiek bericht in een Bitcoin-transactie met behulp van de ‘op_return’-functie.</p>
<p>Dit proces kan worden vergeleken met het graveren van tekst of afbeeldingen op een voorwerp in de fysieke wereld om informatie of markeringen achter te laten. Door de eigenschappen van blockchain-technologie worden deze informatie, zodra ze zijn ‘gegraveerd’ (geregistreerd en bevestigd), permanent opgeslagen in de blockchain en kunnen ze niet worden gewijzigd of verwijderd.</p>
<p>Kort gezegd is ‘het graveren van inies’ een actie waarbij een stuk informatie wordt vastgelegd in de Bitcoin-blockchain. Deze informatie wordt permanent bewaard en kan openbaar worden opgevraagd via de blockchain.</p>
<p>Mensen kiezen misschien voor het graveren van inies vanwege herdenking, authenticatie, auteursrechtverklaring of andere gepersonaliseerde behoeften. Het biedt een onomkeerbare en niet-veranderbare opslagmethode voor informatie, wat in veel scenario’s bijzonder belangrijk is, zoals bijvoorbeeld bij het vastleggen van eigendomsrechten, anti-namaak en het bewaren van historische gegevens.</p>
<h2 id="h2-Wat20is20het20precies20om20inies20te20slaan27276"><a name="Wat is het precies om inies te slaan?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is het precies om inies te slaan?</h2><p>In de context van de Bitcoin blockchain betekent ‘het graveren van inies’ eigenlijk het insluiten van specifieke informatie in Bitcoin transacties. Hier betekent ‘het graveren van inies’ ‘registreren’ of ‘schrijven’. Wanneer mensen het hebben over ‘het graveren van inies’, bedoelen ze meestal het gebruik van een deel van de ruimte van Bitcoin transacties om niet-transactiegegevens op te slaan, zoals berichten of andere soorten tags.</p>
<p>Bij Bitcoin-transacties is er een speciaal type transactie-uitvoer genaamd “op_return”. Deze output wordt niet gebruikt om bitcoins naar een adres te sturen, maar om gegevens op te slaan. Omdat de blockchain van Bitcoin een openbaar en onveranderlijk registratiesysteem is, wordt de informatie die via de “op_return”-uitvoer wordt geschreven, permanent vastgelegd en kan deze door iedereen worden bekeken, maar kan deze niet worden gewijzigd of verwijderd.</p>
<p>Als voorbeeld, als je een gedenkwaardige tekst wilt achterlaten op de Bitcoin blockchain, kun je een Bitcoin-transactie maken met een ‘op_return’-output en je gewenste tekst in de vorm van gegevens in die output insluiten. Dit proces is als het graveren van je boodschap op een eeuwige digitale gedenksteen, die voor altijd zal blijven bestaan met de voortdurende groei van de blockchain. Dit staat bekend als ‘inie’.<br><img src="https://gimg2.gateimg.com/image/article/1706583065img_v3_027j_ada2cd9f-d67b-457a-92a8-ca28f06f4bix.jpg" alt=""></p>
<h2 id="h2-Hoe20graveer20je20inies111764"><a name="Hoe graveer je inies?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe graveer je inies?</h2><p>Kort gezegd is het nodig om speciale softwaretools of programmeerinterfaces (API’s) te gebruiken om inies te slaan.</p>
<p>Allereerst moet de gebruiker de informatie voorbereiden die moet worden ingebed en deze correct coderen. Vervolgens wordt bij het creëren van een Bitcoin-transactie het veld OP_RETURN toegevoegd aan de output en wordt de gecodeerde informatie eraan toegevoegd. Ten slotte wordt deze transactie via het Bitcoin-netwerk uitgezonden. Zodra de transactie wordt bevestigd en aan de blockchain wordt toegevoegd, wordt de inie permanent vastgelegd in het openbare grootboek van Bitcoin.</p>
<h2 id="h2-Conclusie732803"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Het ‘drukken’ van inies is een handeling die doordrenkt is van zowel kunstzinnigheid als technische vaardigheid, waarbij individuele wil en de digitale wereld voor eeuwig met elkaar verbonden worden. In de steeds volwassener wordende wereld van blockchaintechnologie weerspiegelt het ‘drukken’ van inies niet alleen de subtiliteit van technologie, maar ook de wens van individuen om een unieke stempel achter te laten in de digitale wereld. Naarmate blockchaintechnologie dieper doordringt in diverse gebieden, zal het ‘drukken’ van inies ongetwijfeld een steeds belangrijkere rol gaan spelen.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Byron B.</strong>Gate.io onderzoeker<div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen beleggingsadvies.<br>  </em><div><em></em>本文内容为原创，版权为Gate.io所有，如需转载请注明作者和出处，否则将追究法律责任。<br></div><p></p><br></div></div></div>