S2FuIGlrIFJ1bmVzLXRva2VucyBkZWx2ZW4gZG9vciBSU0lDLWluc2NyaXB0aWVzIHRlIGJleml0dGVuPyBXYXQgaXMgaGV0IHZlcnNjaGlsIHR1c3NlbiBpbnNjcmlwdGllcyBlbiBydW5lbj8=

2024-01-30, 02:42

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR269627"><a name="TL;DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL;DR</h2><p>RSIC, voluit Rune Specifieke Inie Circuits, een soort inie, ook een NFT;</p>
<p>Runen is een schema voorgesteld door Casey Rodamor, de oprichter van het Ordinals-protocol;</p>
<p>Inions zijn gerelateerd aan het vastleggen van informatie, terwijl runen meer verband houden met de tokens zelf, waarbij de nadruk ligt op hun uniekheid en functionaliteit;</p>
<p>Terwijl we het populaire rijkdomseffect in de gaten houden, moeten we ook begrijpen wat er schuilgaat achter deze termen.</p>
<h2 id="h2-Inleiding703374"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Met de snelle ontwikkeling van blockchain-technologie komen concepten als ‘inies’ en ‘runen’ steeds meer in de publieke belangstelling. Vooral in het veld van digitale valuta vertegenwoordigen ze een nieuwe vorm van activa en waardeoverdracht. Dit artikel beoogt de concepten van RSIC-inies en runen grondig te analyseren en hun verschillen en unieke rol in de wereld van blockchain te onderzoeken.</p>
<h2 id="h2-Wat20is20RSICinie378043"><a name="Wat is RSIC-inie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is RSIC-inie?</h2><p>RSIC, voluit Rune Specifieke Inie Circuits, is een inie, ook wel bekend als “NFT”, die wordt gebruikt om Runes-tokens te delven. Het is een peer-to-peer distributiesysteem voor runen gebaseerd op Bitcoin, in wezen een digitaal spel.</p>
<p>In dit systeem kunnen spelers runen verkrijgen door RSIC-tokens te beheren en te bedienen. Deze runen zullen op een bepaald moment in de toekomst ‘gegraveerd’ worden op het Bitcoin-netwerk. RSIC-inies zijn eigenlijk een soort mijnbouwcertificaat, dat het recht vertegenwoordigt om een bepaalde token op Runes te delven. Deze token zal door het project op een afgesproken tijdstip in een vast aantal (vaste limiet) worden uitgegeven en volgens vastgestelde regels aan verschillende adressen worden toegewezen. De waarde van RSIC-inies ligt in het feit dat houders ermee toekomstige toewijzingen van Runes-tokens kunnen verkrijgen.</p>
<p>Elke RSIC-inie is gekoppeld aan een Java-inie die de hash-waarde van het nieuwste blok kan vastleggen en analyseren of het laatste cijfer overeenkomt met het symbool rechtsonder in de RSIC. Als dat het g is, verandert de stijl van de inie (bijvoorbeeld in het geel). Dit ontwerp maakt het mogelijk dat inies veranderen naarmate de tijd vordert en de blockchain verandert, wat een dynamisch en interactief element toevoegt.</p>
<p>Bovendien is het project van plan om een billboard systeem te introduceren waarmee gebruikers hun eigen RS-tokens kunnen opvragen zonder voortdurend NFT’s te onderzoeken om te zien of ze van kleur zijn veranderd. Dit systeem stelt gebruikers in staat om hun tokenverbruik en -records rechtstreeks op de officiële website te bekijken. Er zijn ook enkele niet-openbare easter eggs, zoals de boost logica genoemd in de gateway, en deze regels zullen worden gegraveerd op specifieke satoshi.</p>
<p>Over het algemeen vertegenwoordigt de RSIC-inie een poging om nieuwe speelwijzen en toepassingsmodellen te vinden in blockchain technologie. Door gamification-elementen en mining-incentives te combineren, heeft het als doel een nieuwe ecosysteem te creëren dat zowel leuk als mogelijk economische waarde heeft. Echter, omdat dit een relatief nieuw concept is, moet de langetermijnwaarde en impact nog worden getest door de markt en de deelnemers.<br><img src="https://gimg2.gateimg.com/image/article/1706582402img_v3_027j_92747e9b-1eda-44ca-904a-895b3e0b2bix.jpg" alt=""></p>
<h2 id="h2-Wat20zijn20Runes521637"><a name="Wat zijn Runes?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn Runes?</h2><p>Runes is een unieke en vervangbare token die bestaat op de <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> blockchain. Het Runes-protocol, voorgesteld door Casey Rodamor, de oprichter van het Ordinals-protocol, heeft als doel een gebruikersvriendelijk en op UTXO gebaseerd alternatief te bieden voor bestaande tokenisatieprotocollen zoals Ordinals, ORC-20, BRC-20 en Stamps.</p>
<p>In vergelijking met bestaande alternatieven verschilt Rune op verschillende manieren. Ten eerste is Rune gemaakt op basis van het onuitgegeven transactie-uitvoer (UTXO) model van Bitcoin. Dit vermindert effectief de productie van ‘afval’ UTXO’s, wat resulteert in verantwoordelijker UTXO-beheer en een kleinere on-chain voetafdruk. De Bitcoin blockchain is ontworpen als een uiterst kleine en efficiënte grootboek dat wordt gebruikt om waarde over te dragen via Bitcoin-transacties.</p>
<p>Het ontwerp van Runes richt zich op gebruiksvriendelijkheid en heeft het potentieel om belangrijke veranderingen in het Bitcoin-tokenecosysteem te introduceren. Door gebruik te maken van het UTXO-model van Bitcoin biedt Runes een oplossing voor het ‘reduceren van schade’ door onnodige inflatie van de UTXO-set te verminderen, wat een belangrijk probleem is voor bestaande protocollen zoals BRC-20 en Stamps. Het vereenvoudigde ontwerp heeft het potentieel om meer interesse en betrokkenheid van ontwikkelaars aan te trekken, wat mogelijk innovatie in de Bitcoin-ontwikkelingsgemeenschap kan stimuleren. De naadloze gebruikerservaring heeft ook het potentieel om meer mainstream gebruikers aan te trekken, omdat zij zich niet bezig hoeven te houden met native tokens of de complexiteit van off-chain verwerking.</p>
<p>Runes maakt flexibele toewijzing en overdracht van runebalans mogelijk, ongeldige protocoolberichten leiden tot rune-verbranding als garantie voor toekomstige upgrades. Bovendien kunnen runen specifieke menselijk leesbare symbolen en decimale configuraties uitgeven en overdragen zonder gebruik te maken van inheemse tokens, waardoor het protocol eenvoudiger en gebruiksvriendelijker wordt. Over het algemeen biedt Runes een eenvoudigere en intuïtievere manier om vervangbare tokens op de Bitcoin-blockchain te behandelen.<br><img src="https://gimg2.gateimg.com/image/article/1706582442img_v3_027j_f0e867aa-1a98-4dcd-b88c-a743f4415aix.jpg" alt=""></p>
<h2 id="h2-Het20verschil20tussen20inies20en20runen510594"><a name="Het verschil tussen inies en runen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het verschil tussen inies en runen</h2><p>In de wereld van blockchain en cryptocurrency kunnen de termen ‘inie’ en ‘rune’ enige verwarring veroorzaken, omdat ze verschillende betekenissen hebben in verschillende contexten. Over het algemeen hebben deze twee woorden diep gewortelde betekenissen in geschiedenis en mythologie, maar in het blockchain-gebied zijn hun concepten anders.</p>
<p>Een inie verwijst meestal naar tekst of afbeeldingen die op een specifiek object zijn gegraveerd. In de context van blockchain kan een inie (Inion) verwijzen naar het permanent vastleggen van bepaalde informatie, zoals een digitale handtekening of de code van een slim contract, op de blockchain. Deze inie is onveranderlijk en kan niet worden gewijzigd of verwijderd zodra deze op de blockchain is vastgelegd. Dergelijke inies kunnen worden gebruikt om eigendom, identiteit of andere belangrijke informatie te bewijzen. Bijvoorbeeld, in het veld van NFT’s (niet-fungibele tokens), kan een inie verwijzen naar metadata of kunstwerken die permanent op een NFT zijn vastgelegd.</p>
<p>Runen zijn karakters uit een oud alfabetisch systeem en worden vaak gebruikt om mysterieuze of magische symbolen aan te duiden. In de blockchain-wereld kan Rune verwijzen naar een speciaal type token of asset, dat meestal specifieke eigenschappen of doeleinden heeft.</p>
<p>Bijvoorbeeld, in sommige games of gedecentraliseerde financiële (DeFi) projecten, kunnen runen tokens vertegenwoordigen die gebruikers kunnen verzamelen, verhandelen of gebruiken om specifieke effecten te verkrijgen. Deze runen kunnen de houder bepaalde rechten of capaciteiten geven, zoals stemrecht, recht op inkomsten, enzovoort.</p>
<p>Kortom, inies gaan over het vastleggen van informatie, met de nadruk op permanentie en onveranderlijkheid; terwijl symbolen meer gerelateerd zijn aan de tokens zelf, met de nadruk op hun uniciteit en functionaliteit.<br><img src="https://gimg2.gateimg.com/image/article/1706582467img_v3_027j_7e0bbaca-5129-4215-a808-7c6d750d9cix.jpg" alt=""></p>
<h2 id="h2-Hoe20Runes20te20mijnen119818"><a name="Hoe Runes te mijnen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe Runes te mijnen?</h2><p>RSIC is een peer-to-peer runenverdelingssysteem met een totaal van 21000 runen. Hiervan is 10% gereserveerd voor het team, 11 RSIC wordt overgedragen naar Satoshi Nakamoto’s account, en de resterende runen worden airdropped naar 9211 adressen van de Ordinals-gemeenschap. De airdrop-criteria zijn niet gedetailleerd beschreven. Als er ORDI, Node Monkey en andere activa in de portefeuille aanwezig zijn, kunt u hierop letten.</p>
<p>Volgens de officiële introductie is RSIC zelf een specifieke runenetische circuit voor het delven van runen. Op het eerste gezicht lijkt het wat vaag, maar in wezen kan het worden beschouwd als een ‘mijnbouwmachine’. Om de mijnbouwcapaciteit te activeren, moet RSIC, dat aan het Ordinals-gemeenschapsadres is toegekend, nog een keer worden overgedragen. Bij aankoop op de secundaire markt wordt het automatisch geactiveerd.</p>
<p>Na activering zal RSIC runen delven in de nieuwe blokken van het Bitcoin-netwerk. De specifieke hoeveelheid gedolven runen kan momenteel nog niet worden opgevraagd, maar er zal later een officiële front-end beschikbaar worden gesteld voor het opvragen. Het is belangrijk op te merken dat hoe meer RSIC’s er in een adres worden gehouden, hoe meer runen er worden gedolven, zonder limiet te stellen.</p>
<p>Het echt interessante spel van de RSIC-gemeenschap ligt in het mijnbouwproces, waarbij er vier verschillende manieren van verdeling van symbolen zijn, namelijk de vaste modus, de willekeurige modus, de verbeterde modus en de gehalveerde modus, die de willekeurigheid van mijnbouwbeloningen verhogen en meer lijken op een inie-mijnbouwspel. Tegelijkertijd deelt KOL Sillycat.sats op het X-platform zijn RSIC-rariteitstabel op basis van de speciale symbolen van RSIC.</p>
<h2 id="h2-Conclusie99844"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Inies en runen vertegenwoordigen twee belangrijke concepten in blockchain-technologie. Ze spelen een onmisbare rol in domeinen zoals digitale valuta en slimme contracten.</p>
<p>Het is van vitaal belang voor iedereen die diepere kennis wil hebben van blockchain technologie om hun functies, verschillen en onderlinge relaties te begrijpen. Met de voortdurende vooruitgang van technologie en de steeds rijker wordende toepassingsgebieden, zullen inies en symbolen ongetwijfeld een steeds belangrijkere rol spelen in ons digitale leven.</p>
<p>Tegelijkertijd is het belangrijk om de concepten achter deze termen te begrijpen terwijl we ons richten op het vermogenseffect, wat essentieel is voor het begrijpen en deelnemen aan blockchain-projecten.</p>
<p>Naarmate steeds meer mensen dit gebied gaan verkennen, zal het duidelijk begrijpen van deze basisconcepten helpen om de ontwikkelingsrichting en het potentieel van de markthotspots beter te begrijpen.</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 enkele handelsaanbeveling.<br></em><div><em></em>De inhoud van dit artikel is origineel en is eigendom van Gate.io. Als u het wilt herdrukken, vermeld dan de auteur en de bron, anders zullen juridische verantwoordelijkheden worden nageleefd.<br></div><p></p><br></div></div></div>