TkZULXZyYWFnIG92ZXJ3ZWxkaWd0IGludGVybmV0LCB2ZXJ0cmFhZ3QgaGV0IG1pbnRpbmctcHJvY2VzIHZhbiBNYWQgTGFkcw==

2023-05-06, 01:44

<p><img src="https://gimg2.gateimg.com/image/article/1682586049RDZZ.jpeg" alt=""><br>Het NFT-mintproces van de Mad lads werd met 24 uur vertraagd vanwege de hoge verkeersdrukte op de Backpack wallet.</p>
<p>Het gebruik van bots om het xNFT-muntproces te automatiseren kan tot veel verkeer op het netwerk hebben geleid.</p>
<p>Het gebruik van kunstmatige intelligentie in de blockchain sector heeft de productie en vraag naar NFT’s verhoogd.</p>
<p><strong>Trefwoorden</strong>: Mad lads NFT, wat is een xNFT, uitvoerbare NFT, NFT muntproces, muntproces, NFT’s in 2023, soorten NFT’s</p>
<h2 id="h2-Introductie289917"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De NFT-technologie blijft veranderen naarmate er nieuwe functies op de markt komen. Het gebruik van kunstmatige intelligentie (AI) en de ontwikkeling van verschillende soorten NFT’s zoals fractionele NFT’s en dynamische NFT’s hebben het gebruik van niet-vervangbare tokens vergroot. In dit artikel bespreken we wat xNFT’s zijn en waarom ze zeer gewild zijn.</p>
<h2 id="h2-De20populariteit20van20NFTs20in202023760933"><a name="De populariteit van NFT’s in 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De populariteit van NFT’s in 2023</h2><p>Met de vooruitgang van de blockchaintechnologie en de toepassing ervan in het echte leven zijn NFT’s populair geworden. De introductie van kunstmatige intelligentie in de blockchainsector heeft geleid tot een grotere adoptie van NFT’s. Mensen gebruiken bijvoorbeeld kunstmatige intelligentie om unieke kunstwerken en animaties te genereren die kunnen worden omgezet in NFT’s.</p>
<p>De integratie van NFT’s in games en de metaverse is een andere drijvende kracht van de <a href="https://www.gate.io/blog_detail/2286" target="_blank">vraag en populariteit van NFT’s</a>. Veel in-game assets zoals wezens, wapens en valuta’s zijn in de vorm van NFT’s. De toenemende interesse in op blockchain gebaseerde spellen betekent een stijgende vraag naar NFT’s.<br><img src="https://gimg2.gateimg.com/image/article/16833372491.png" alt=""><br>De Mad Lads NFT’s - Startwithnfts</p>
<p>NFT’s hebben ook veel tractie gekregen op blockchain-aangedreven sociale media platforms, waar ze worden gebruikt als profielfoto’s die eigendom en controle van gegevens vertegenwoordigen. Dit verbetert ook de monetisatie van digitale inhoud. Bijvoorbeeld, gebruikers kunnen hun digitale inhoud maken en verkopen om beloningen te verdienen.</p>
<p>NFT’s spelen een grotere rol in gedecentraliseerde financiën dan ooit tevoren. Dit komt doordat op NFT gebaseerde gedecentraliseerde financiën effecten zoals obligaties en aandelen kunnen tokeniseren, waardoor fractioneel eigendom en investering in dergelijke activa mogelijk is.</p>
<p>Ook, <a href="https://www.gate.io/learn/articles/what-are-nfts/4" target="_blank">NFT’s zijn nuttig</a> in de evenementenbeheer- en luchtvaartsector waar mensen ze gebruiken als e-tickets. Als gevolg hiervan gebruiken veel evenementenbeheerders NFT-tickets omdat ze veilig zijn en minder duur dan papieren tickets.</p>
<h2 id="h2-Wat20is20een20xNFT736378"><a name="Wat is een xNFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is een xNFT?</h2><p>Mad lads NFT is een trending blockchain-gebaseerd project, bekend om zijn xNFT’s. Zeker, Mad lads NFT’s, ook wel xNFT’s genoemd, zijn een nieuw soort niet-vervangbare tokens die meer zijn dan JPEG-afbeeldingen die op de blockchain bestaan.</p>
<p>Het is vermeldenswaard dat Mad lads een slang is die in Engeland werd gebruikt tijdens de jaren 2000 en verwijst naar gekke tieners die veel van hun tijd doorbrachten met feesten in plaatsen zoals pubs. Op dezelfde manier trokken ze veel aandacht vanwege hun bizarre acties.</p>
<p>Daarom bieden de kunststijlen van Mad lads mensen een gevoel van het gedrag van deze oudere generatie jongeren en het type kleding dat ze droegen. Desalniettemin bevat de collectie ook afbeeldingen van robots en buitenaardse wezens.</p>
<p>xNFT’s vertegenwoordigen in feite getokeniseerde codes die hun eigenaars eigendomsrechten geven over hun uitvoeringen. Met andere woorden, een xNFT-houder kan bepaalde activiteiten uitvoeren vanwege zijn/haar eigendom van de token. Het is belangrijk op te merken dat de Mad lads NFT’s de eerste verzameling van xNFT’s zijn.</p>
<p>Armani Ferrante en Tristan Yver, twee bekende persoonlijkheden in de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Ecosysteem, zijn de mensen achter het Mad lads NFT-project en de Backpack-portemonnee.</p>
<h2 id="h2-Het20belang20van20xNFTs869612"><a name="Het belang van xNFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het belang van xNFT’s</h2><p>We kunnen de xNFT’s beschouwen als applicaties. Specifiek staat de x in xNFT voor uitvoerbare, getokeniseerde code die werkt binnen Backpack. Bijvoorbeeld, de uitvoerbare NFT stelt de houder in staat om digitale activa zoals een airdrop naar veel mensen tegelijk te sturen met behulp van de Backpack wallet.</p>
<p>Bovendien stelt de Backpack-portemonnee mensen in staat om meerdere toepassingen op één plek te hebben. Individuen kunnen de xNFT gebruiken als platforms voor bruikbare gedecentraliseerde toepassingen waar ze verschillende digitale activa kunnen openen zonder te vertrouwen op software van derden.</p>
<p>Met andere woorden gedragen xNFT’s zich als gedecentraliseerde applicaties die bestaan in de Backpack-portemonnee waar gebruikers hun eigen games, applicaties en andere digitale activa kunnen ontwikkelen en lanceren.</p>
<h2 id="h2-Waarom20zijn20de20Mad20lads20NFTs20zeer20gewild959043"><a name="Waarom zijn de Mad lads NFT’s zeer gewild" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarom zijn de Mad lads NFT’s zeer gewild</h2><p>De uitvoerbare NFT’s zijn in trek omdat ze game-ontwikkelaars, NFT-kunstenaars en andere gebruikers eigendomsrechten geven om verschillende digitale producten te ontwikkelen. Zo kunnen game-ontwikkelaars bijvoorbeeld hun spellen creëren die bestaan als xNFT’s binnen de cryptowallet. Op dezelfde manier kunnen kunstenaars 3D-ervaringen creëren die in de portemonnee blijven en op geen enkele manier gerepliceerd kunnen worden.</p>
<h2 id="h2-Begrijpen20van20de20Backpackportemonnee163096"><a name="Begrijpen van de Backpack-portemonnee" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Begrijpen van de Backpack-portemonnee</h2><p>Zoals eerder vermeld, is de Backpack, ook wel bekend als de wallet-app van Coral, de enige <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Backpack is een op blockchain gebaseerde portemonnee die xNFT’s bevat. In feite is Backpack een cryptoportemonnee die functioneert als MetaMask, maar geavanceerder is. Het is uniek omdat het een digitale portemonnee is die ook fungeert als een applicatiebeheerprotocol en het enige platform is waar mensen uitvoerbare NFT’s (xNFT’s) kunnen maken.<br><img src="https://gimg2.gateimg.com/image/article/16833373172.png" alt=""><br>Rugzak portemonnee - Goosefx</p>
<h2 id="h2-Vertragingen20in20het20NFTmintproces20van20Madlads6420"><a name="Vertragingen in het NFT-mintproces van Madlads" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vertragingen in het NFT-mintproces van Madlads</h2><p>De langverwachte lancering van de <a href="https://decrypt.co/138125/mad-lads-given-solana-nfts-new-heartbeat-after-losing-degods-coral-ceo" rel="nofollow noopener noreferrer" target="_blank">Mad lads NFT-muntprogramma</a> om 7 PM ET op 20 april zou plaatsvinden, is met een dag uitgesteld vanwege enkele technische uitdagingen.</p>
<p>In feite werd deze vertraging veroorzaakt door te veel verkeer op de Backpack-portemonnee waar het muntproces zou plaatsvinden. Volgens een bron werden miljarden verzoeken via de Backpack-cryptowallet geleid, wat resulteerde in een Distributed Denial of Service. <a href="https://www.gate.io/bitwiki/detail/152/distributed-denial-of-service-attack--ddos-attack &quot;(DdoS" rel="nofollow noopener noreferrer" target="_blank">(DdoS) aanval</a> aanval”).</p>
<p>In eenvoudige bewoordingen vindt een DDoS-aanval plaats wanneer er een poging wordt gedaan om het normale verkeer naar een server of netwerk te blokkeren. We kunnen ze vergelijken met verkeersopstoppingen op snelwegen die de verkeersbeweging vertragen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/902/minting-purchasing-and-trading-nft-art" target="_blank">NFT Kunst maken, kopen en verhandelen</a></p>
<p>Soms wordt DdoS veroorzaakt door netwerken die malware hebben die worden gecontroleerd door slechte actoren. Dergelijke apparaten die het netwerk vertragen worden bots genoemd, die verzoeken naar een netwerk sturen.</p>
<p>Daarom waren er te veel verzoeken die de en van Backpack en Mad lads vertraagden, waardoor netwerkstoringen ontstonden. Deze hoge vraag zou veroorzaakt kunnen zijn door te veel aanmeldingen op de Backpack wallet-app die de Mad lads NFT-collectie ondersteunt.<br><img src="https://gimg2.gateimg.com/image/article/16833373953.png" alt=""><br>Mad lads NFT-collectie. Bron: NFT Nu</p>
<p>Om deze uitdaging te overwinnen, zette het Mad lads team een honeypot val op die de bots lokte die de mints wilden automatiseren. Uiteindelijk nam het systeem de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> tokens (SOL) die de bot van plan was te gebruiken tijdens het mintproces. Het team heeft echter de SOL geretourneerd na voltooiing van het mintproces.</p>
<h2 id="h2-Conclusie505173"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De gekken <a href="https://www.gate.io/blog_detail/510" target="_blank">NFT muntproces</a> werd met 24 uur vertraagd vanwege te veel verkeer op de Backpack crypto wallet. Desalniettemin ging het muntproces door nadat het team van Mad lads de bots die het proces automatiseerden, had getraceerd.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>