T3JkaW5hbHMgTkZUICdHZW5lc2lzIENhdCcgc29sZCBmb3IgJDI1MCwwMDAsIHdoYXQga2luZCBvZiBjYXQgaXMgUXVhbnR1bSBDYXQ/

2024-01-30, 03:40

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TD20LR807107"><a name="TD; LR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TD; LR</h2><p>Onlangs is de NFT-markt niet erg goed, de meeste on-chain NFT’s zijn bijna waardeloos geworden, maar op dit moment springt de ‘Genesis Cat’ van Ordinals NFT eruit met een verbazingwekkende transactieprijs. Wat maakt deze serie zo aantrekkelijk? Kan het de grote trend van Ordinals NFT openen?</p>
<h2 id="h2-Wat20zijn20CryptoKitties20en20Quantum20Kitties363806"><a name="Wat zijn CryptoKitties en Quantum Kitties?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn CryptoKitties en Quantum Kitties?</h2><p>Op 23 januari kondigde de bekende veilinghuis Sotheby’s aan dat de speciale editie van het <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Ordinals NFT-project ‘Quantum Cat’ - ‘Genesis Cat’ - is verkocht voor meer dan 250.000 dollar.</p>
<p>“Genesis Cat” is gemaakt door digitale kunstenaar FAR, heeft meer dan 50 biedingen ontvangen en is uiteindelijk verkocht voor de prijs van 6,31 BTC, wat overeenkomt met ongeveer 254.000 dollar. De Quantum Cats zijn een serie bitcoin NFT’s die worden uitgegeven door het Taproot Wizards-team.</p>
<p>Het lijkt erop dat ‘Genesis Cat’ een afbeelding is die bestaat uit 3333 Bitcoin NFT’s met een kattenvorm, en dit staat in nauw verband met de gietkosten, het aantal, de technische oorsprong en het verhaal van de hele ‘Quantum Cat’ serie.<br><img src="https://gimg2.gateimg.com/image/article/1706585902img_v3_027j_90fd9945-e4fe-4c99-a188-5582b37f1cix.jpg" alt=""><br>Bron afbeelding: sothebys com</p>
<p>Quantum Cat beschrijft zichzelf als een ‘evolutie-inie’. Omdat elke ‘Quantum Cat’ constant verandert in de tijd, is deze verandering onzeker en volgens Taproot Wizards zal het onzekerheidsveranderingen ondergaan naarmate het ‘verhaallijn zich ontwikkelt’.</p>
<p>Dit klinkt inderdaad erg interessant, het heeft enige gelijkenis met het concept van de bekende ‘Schrödinger’s kat’. Voor het openen van de doos bevindt de kat zich in een superpositie van ‘verschillende mogelijkheden’, wat precies overeenkomt met de klassieke theorie van de kwantummechanica. Het is te zeggen dat het ontdekken van dit feit iemand zou laten uitroepen dat de naam ‘kwantumkat’ uiterst conceptueel en slim is, en niet alleen maar een meme die sleutelwoorden herhaalt.</p>
<p>Zowel als een inie-activa als een Bitcoin NFT, zijn ze geen nieuwe verschijning, maar zonder twijfel heeft Quantum Cat een bijzonder ‘evolutionair inie’-houding gewonnen en heeft het een voldoende bijzonder verhaal aan de cryptowereld gebracht.</p>
<p>Maar hoe wordt deze ‘dynamiek’ gepresenteerd? Volgens onze inherente kennis zijn ingeschreven activa onveranderlijk zodra ze zijn ingeschreven, en ‘onveranderlijkheid’ is zelfs een integraal onderdeel van het inschrijvingsverhaal. Bovendien, aangezien de Bitcoin-mainnet geen slimme contracten ondersteunt, hoe kan deze ‘onvoorspelbare verandering’ dan worden bereikt?</p>
<h2 id="h2-De20dynamische20verandering20van20Quantum20Cat2020Recursieve20inie225451"><a name="De ‘dynamische verandering’ van Quantum Cat - Recursieve inie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De ‘dynamische verandering’ van Quantum Cat - Recursieve inie</h2><p>Volgens de kernleden van Taproot Wizard hebben ze verschillende technieken gebruikt om de dynamische verandering van quantumkatten te realiseren: recursieve inies, vooraf ondertekende transacties, symmetrische versleuteling, client load management.</p>
<p>De kern van het bereiken van het uiteindelijke effect van de quantumkat is nog steeds de toepassing van recursieve inies. Kort gezegd maakt de recursieve inie het mogelijk dat inies elkaar kunnen refereren en inhoud kunnen ophalen, waardoor dynamische veranderingen in het beeld worden gerealiseerd door andere inies in de referentieketen te gebruiken, dus ‘dynamische verandering’ is het resultaat van het real-time aanroepen van inhoud en rendering.<br><img src="https://gimg2.gateimg.com/image/article/1706585939img_v3_027j_0502f2fc-113f-4163-a704-70f7625984ix.jpg" alt=""><br>Afbeeldingsbron: Twitter</p>
<p>Daarnaast zijn technologieën zoals symmetrische encryptie, client-side load balancing, enz. bedoeld om gegevens veilig en vertrouwelijk te houden, lekkage te voorkomen en de browse-ervaring te verbeteren, oftewel de gebruiksvriendelijkheid.</p>
<h2 id="h2-Het20narratieve20mem20van20de20kwantumkat2020de20opleving20van20oude20code410969"><a name="Het narratieve mem van de kwantumkat - de opleving van oude code?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het narratieve mem van de kwantumkat - de opleving van oude code?</h2><p>De introductie van Quantum Cat is eigenlijk gerelateerd aan recent onderzoek naar Bitcoin-technologie, waarbij verwezen wordt naar een recall van de ‘ancient Bitcoin code’ - ‘OP_CAT’, een opcode die door Satoshi Nakamoto uit de Bitcoin-taal is verwijderd en waarvan sommige Bitcoin-ontwikkelingsbibliotheken willen dat deze wordt hersteld.</p>
<p>OP_CAT maakte het mogelijk om strings samen te voegen en twee elementen samen te voegen tot één, maar vanwege de stabiliteit en schaalbaarheid van het netwerk en om te voorkomen dat Bitcoin-nodes crashen, werd deze code uiteindelijk in 2010 verwijderd.</p>
<p>Echter, met de tijd, is het probleem van de stapeluitbreiding veroorzaakt door OP_CAT niet langer een obstakel, en heeft het huidige Bitcoin-ecosysteem eigenlijk meer behoefte aan geavanceerde of complexe slimme contracten of protocollen. En sommige Bitcoin-forks, zoals <a href="/price/bitcoin-cash-bch" target="_blank" class="blog_inner_link">Bitcoin Cash</a> (BCH), <a href="/price/bitcoin-cash-bch" rel="nofollow noopener noreferrer" target="_blank">Bitcoin Cash</a>) en sidechain Liquid Network, heeft OP_CAT hersteld en de bruikbaarheid ervan bevestigd.</p>
<p>Daarom willen de kernontwikkelaars van Bitcoin zijn functionaliteit opnieuw activeren en hebben ze een voorstel voor verbetering van Bitcoin uitgebracht met de naam ‘OP_CAT’. Ze hebben een nieuwe tap-operatiecode gedefinieerd die het mogelijk maakt om twee waarden op de stapel aan elkaar te koppelen, geïnspireerd door oud verwijderde code. Met een soft fork van 13 regels code wordt er vaart gezet achter de slimme contracten van Bitcoin.</p>
<p>Quantum Cat maakt gebruik van de essentie van dit ‘voortdurende stapelen, verandering en bijwerken’ van narratief, in verbinding met zichzelf, niet alleen als een inie, maar ook als een variabele inie; het is in wezen code voor het oproepen en genereren van afbeeldingen, maar omvat ook de verbinding tussen de Bitcoin-ecosysteem en technologische vooruitgang.</p>
<p>Het gieten van Quantum Cats heeft aanzienlijke kosten met zich meegebracht, het graveren van 3333 katten heeft meer dan 60000 dollar gekost en gebruikte 10M cryptografische ketengegevens. Maar het is duidelijk dat de gemeenschap ook snel het symbool en de waarde van Quantum Cats heeft erkend.</p>
<h2 id="h2-Samenvatting908677"><a name="Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvatting</h2><p>Het rapport van Galaxy Research and Mining voorspelt dat de marktkapitalisatie van het iniemarkt gecreëerd door Ordinals in 2025 $5 miljard zal bedragen. Hoewel de recente populariteit van het iniemarkt niet zo groot is als die van december, zien we juist verschillende technologische overwegingen en innovaties voortkomen uit de inies.</p>
<p>Het wordt waardevoller om aandacht te besteden aan en te investeren in hoogwaardige projecten op basis van de mogelijkheid van inies om slimme contracten of ecosysteemontwikkeling te stimuleren. Door Gate.io te volgen, kunt u deelnemen aan nieuwe verhalen in de iniemarkt, de nieuwste informatie krijgen en vooraf investeren in hoogwaardige doelen.</p>
<p>De verkoopprijs van Genesis Cat brengt meer discussie over de Quantum Cat NFT-serie en Bitcoin NFT naar de gemeenschap; naar verluidt zal de bredere veiling van deze serie plaatsvinden op 29 januari.</p>
<div class="blog-details-info"><div>Auteur:<strong>Sherry S.</strong>, Onderzoeker bij Gate.io<div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen enkel handelsadvies.<br>  </em><div><em></em>De inhoud van dit artikel is origineel en het auteursrecht is in handen van Gate.io. Als u dit artikel wilt herdrukken, vermeld dan de auteur en de bron, anders zullen juridische verantwoordelijkheden worden nagestreefd.<br></div><p></p><br></div></div></div>