TGEgZG9tYW5kYSBkaSBNYWQgbGFkcyBORlQgdHJhdm9sZ2UgSW50ZXJuZXQsIHJpdGFyZGFuZG8gaWwgcHJvY2Vzc28gZGkgc3RhbXBh

2023-05-06, 01:44

<p><img src="https://gimg2.gateimg.com/image/article/1682586049RDZZ.jpeg" alt=""><br>Il processo di creazione degli NFT dei Mad lads è stato ritardato di 24 ore a causa dell’alto traffico sul portafoglio Backpack.</p>
<p>L’uso di bot per automatizzare il processo di creazione di xNFT potrebbe aver causato un elevato traffico sulla rete.</p>
<p>L’uso dell’intelligenza artificiale nel settore della blockchain ha aumentato la produzione e la domanda di NFT.</p>
<p><strong>Parole chiave</strong>: Mad lads NFT, cos’è un xNFT, un NFT eseguibile, la creazione di NFT, processo di creazione, NFT nel 2023, tipi di NFT</p>
<h2 id="h2-Introduzione775118"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La tecnologia NFT continua a cambiare con l’introduzione di nuove funzionalità sul mercato. L’uso dell’intelligenza artificiale (AI) e lo sviluppo di diversi tipi di NFT come i NFT frazionari e i NFT dinamici hanno aumentato i casi d’uso dei token non fungibili. In questo articolo, discutiamo di cosa sono gli xNFT e perché sono molto richiesti.</p>
<h2 id="h2-La20popolarit20degli20NFT20nel202023346243"><a name="La popolarità degli NFT nel 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La popolarità degli NFT nel 2023</h2><p>Con l’avanzamento della tecnologia blockchain e la sua applicazione nella vita reale, gli NFT sono diventati popolari. L’introduzione dell’intelligenza artificiale nel settore blockchain ha portato ad una maggiore adozione degli NFT. Ad esempio, le persone utilizzano l’intelligenza artificiale per generare opere d’arte e animazioni uniche che possono essere convertite in NFT.</p>
<p>L’integrazione delle NFT nei giochi e nel metaverso è un altro fattore trainante del <a href="https://www.gate.io/blog_detail/2286" target="_blank">domanda e popolarità degli NFT</a>. Molti asset in-game come creature, armi e valute sono sotto forma di NFT. L’interesse crescente nei giochi basati su blockchain comporta un aumento della domanda di NFT.<br><img src="https://gimg2.gateimg.com/image/article/16833372491.png" alt=""><br>Gli NFT di The Mad Lads - Startwithnfts</p>
<p>Anche gli NFT hanno guadagnato molta popolarità nelle piattaforme di social media alimentate da blockchain, dove vengono utilizzati come immagini del profilo che rappresentano la proprietà e il controllo dei dati. Questo aumenta anche la monetizzazione dei contenuti digitali. Ad esempio, gli utenti possono creare e vendere i propri contenuti digitali per guadagnare ricompense.</p>
<p>Gli NFT hanno un ruolo sempre più importante nella finanza decentralizzata. Ciò perché la finanza decentralizzata basata su NFT può tokenizzare titoli come obbligazioni e azioni, consentendo la proprietà frazionata e gli investimenti in tali asset.</p>
<p>Inoltre, <a href="https://www.gate.io/learn/articles/what-are-nfts/4" target="_blank">Gli NFT sono utili</a> nei settori della gestione degli eventi e dei viaggi aerei dove le persone li utilizzano come biglietti elettronici. Di conseguenza, molti organizzatori di eventi utilizzano i biglietti NFT poiché sono sicuri e meno costosi dei biglietti cartacei.</p>
<h2 id="h2-Cos20un20xNFT910237"><a name="Cos’è un xNFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è un xNFT?</h2><p>Mad lads NFT è un progetto basato su blockchain di tendenza, noto per i suoi xNFT. Certamente, i Mad lads NFT, anche chiamati xNFT, sono un nuovo tipo di token non fungibili che sono più di semplici immagini JPEG che esistono sulla blockchain.</p>
<p>Vale la pena notare che Mad lads è uno slang usato in Inghilterra durante gli anni 2000 che si riferisce a ragazzi pazzi che passavano gran parte del loro tempo a fare festa in luoghi come pub. Allo stesso modo, attiravano molta attenzione a causa delle loro azioni bizzarre.</p>
<p>Pertanto, gli stili artistici dei pazzi forniscono alle persone una sensazione dei comportamenti dei giovani della generazione precedente e del tipo di abbigliamento che indossavano. Tuttavia, la collezione comprende anche immagini di robot e creature aliene.</p>
<p>Fondamentalmente, gli xNFT rappresentano codici tokenizzati che conferiscono ai loro detentori diritti di proprietà sulle loro esecuzioni. In altre parole, un detentore di xNFT può eseguire determinate attività a causa della sua proprietà del token. È importante notare che i Mad lads NFT sono la prima collezione di xNFT.</p>
<p>Armani Ferrante e Tristan Yver, due personalità ben note nel <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> L’ecosistema, sono le persone dietro il progetto NFT dei Mad lads e il portafoglio Backpack.</p>
<h2 id="h2-Limportanza20delle20xNFT47728"><a name="L’importanza delle xNFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’importanza delle xNFT</h2><p>Possiamo considerare gli xNFT come applicazioni. In particolare, la x in xNFT sta per codice eseguibile tokenizzato che funziona all’interno di Backpack. Ad esempio, l’NFT eseguibile consente al suo detentore di inviare asset digitali come airdrop a molte persone contemporaneamente utilizzando il portafoglio Backpack.</p>
<p>Inoltre, il portafoglio Backpack consente alle persone di avere più applicazioni in un unico posto. Gli individui possono utilizzare l’xNFT come piattaforme per applicazioni decentralizzate operabili, in cui possono accedere a vari beni digitali senza dover fare affidamento su software di terze parti.</p>
<p>In altre parole, gli xNFT funzionano come applicazioni decentralizzate che esistono nel portafoglio Backpack in cui gli utenti possono sviluppare e lanciare i propri giochi, applicazioni e altri asset digitali.</p>
<h2 id="h2-Perch20i20Mad20lads20NFT20sono20molto20richiesti304559"><a name="Perché i Mad lads NFT sono molto richiesti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Perché i Mad lads NFT sono molto richiesti</h2><p>Gli NFT eseguibili sono richiesti perché offrono ai sviluppatori di giochi, agli artisti NFT e ad altri utenti i diritti di proprietà per sviluppare vari prodotti digitali. Ad esempio, i sviluppatori di giochi possono creare i loro giochi che esistono come xNFT nel portafoglio crittografico. Allo stesso modo, gli artisti possono creare esperienze 3D che rimangono nel portafoglio e che non possono essere replicate in alcun modo.</p>
<h2 id="h2-Comprensione20del20portafoglio20Backpack613667"><a name="Comprensione del portafoglio Backpack" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Comprensione del portafoglio Backpack</h2><p>Come accennato in precedenza, lo zaino, noto anche come l’app del portafoglio Coral, è l’unico <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> un portafoglio basato su blockchain che ospita xNFT. In effetti, Backpack è un portafoglio cripto che funziona come MetaMask ma è più avanzato di esso. È unico poiché è un portafoglio digitale che funge anche da protocollo di gestione delle applicazioni ed è l’unica piattaforma in cui le persone possono creare NFT eseguibili (xNFT).<br><img src="https://gimg2.gateimg.com/image/article/16833373172.png" alt=""><br>Portafoglio zaino - Goosefx</p>
<h2 id="h2-Ritardi20nel20processo20di20creazione20di20NFT20di20Madlads559452"><a name="Ritardi nel processo di creazione di NFT di Madlads" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ritardi nel processo di creazione di NFT di Madlads</h2><p>Il tanto atteso lancio del <a href="https://decrypt.co/138125/mad-lads-given-solana-nfts-new-heartbeat-after-losing-degods-coral-ceo" rel="nofollow noopener noreferrer" target="_blank">Programmazione di creazione di NFT di Mad lads</a> avrebbe dovuto svolgersi alle 19:00 ET del 20 aprile è stato ritardato di un giorno a causa di alcune sfide tecniche.</p>
<p>In realtà, questo ritardo è stato causato da troppo traffico sul portafoglio Backpack dove avrebbe dovuto avvenire il processo di coniazione. Secondo una fonte, miliardi di richieste sono state instradate attraverso il portafoglio cripto Backpack, causando un attacco di negazione del servizio distribuito. <a href="https://www.gate.io/bitwiki/detail/152/distributed-denial-of-service-attack--ddos-attack" target="_blank">(DdoS) attacco</a>.</p>
<p>In parole semplici, un attacco DDoS si verifica quando c’è un tentativo di bloccare il normale traffico verso un server o una rete. Possiamo paragonarli a ingorghi stradali che rallentano il movimento del traffico.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/902/minting-purchasing-and-trading-nft-art" target="_blank">Creazione, Acquisto e Trading di Arte NFT</a></p>
<p>A volte il DdoS è causato da reti che hanno malware controllati da attori malintenzionati. Tali dispositivi che possono rallentare la rete vengono chiamati bot che inviano richieste a una rete.</p>
<p>Pertanto, c’erano troppe richieste che hanno rallentato i sistemi Backpack e Mad lads causando interruzioni di rete. Questa elevata domanda potrebbe essere stata causata da troppe registrazioni sull’app del portafoglio Backpack che supporta la collezione NFT di Mad lads.<br><img src="https://gimg2.gateimg.com/image/article/16833373953.png" alt=""><br>Collezione Mad Lads NFT. Fonte: NFT Now</p>
<p>Per superare questa sfida, il team dei Mad lads ha schierato una trappola honeypot che ha attirato i bot che volevano automatizzare le miniere. Alla fine, il sistema ha preso il <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> token (SOL) che il bot aveva intenzione di utilizzare durante il processo di coniazione. Tuttavia, il team ha restituito il SOL dopo il completamento del processo di coniazione.</p>
<h2 id="h2-Conclusione355142"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>I ragazzi pazzi <a href="https://www.gate.io/blog_detail/510" target="_blank">Processo di creazione di NFT</a> È stato ritardato di 24 ore a causa del troppo traffico sul portafoglio crittografico Backpack. Tuttavia, la coniazione è continuata dopo che il team Mad lads ha intrappolato i bot che automatizzavano il processo.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripost del articolo a patto che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>