VmVuZGl0YSBDcnlwdG9QdW5rIE5GVCBbRmFsc2FdOiBVbmEgRmFjY2lhdGEgZGkgUHJlc3RpdG8gRmxhc2ggaW4gTWV6em8gYWwgRGVjbGlubyBkZWwgTWVyY2F0byBORlQ=

<p><img src="https://gimg2.gateimg.com/image/article/17290465081692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR725491"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>L’acquisto di CryptoPunk 1563 il 1 ottobre si è rivelato essere una trovata di marketing.</p>
<p>Un analista ritiene che la vendita di CryptoPunk 1563 per 24.000 ETH sia stata preparata in vista del lancio di Kamala Harris Punk NFT.</p>
<p>La manipolazione di mercato nel settore NFT potrebbe diminuire la fiducia degli investitori e la fiducia nei beni.</p>
<h2 id="h2-Introduzione87991"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Anche se i token non fungibili <a href="https://www.gate.io/learn/articles/breakthrough-of-nft-bringing-fungible-tokens-and-nfts-together/1997 &quot;(NFTs" rel="nofollow noopener noreferrer" target="_blank">Gli NFT non sono così popolari come le criptovalute</a> non sono popolari quanto le criptovalute”), le persone spesso le acquistano a prezzi elevati. Purtroppo, ci sono momenti in cui i venditori ricorrono alla manipolazione di mercato per trarre maggiori benefici. Ad esempio, a volte gli investitori acquistano NFT falsi senza alcun valore sul mercato. In questa analisi ci concentriamo su un recente caso di manipolazione di mercato in cui un presunto investitore ha acquistato un NFT per la cifra record di $53,6 milioni.</p>
<h2 id="h2-Un20caso20di20vendita20falsa20CryptoPunk20NFT20venduto20per20536009858"><a name="Un caso di vendita falsa: CryptoPunk NFT venduto per $53.600" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un caso di vendita falsa: CryptoPunk NFT venduto per $53.600</h2><p>Il settore delle criptovalute è stato scosso dalla recente vendita di CryptoPunk 1563 per 24.000 ETH, del valore di circa 56,3 milioni di dollari al momento della transazione. A seguito del prezzo di vendita inaspettato, molte persone hanno messo in dubbio l’autenticità della transazione. Dopo un’analisi dettagliata della blockchain, alcuni analisti hanno concluso che la vendita del <a href="https://www.gate.io/learn/articles/what-is-crypto-punk-nft/4288" target="_blank">Token non-fungibile (NFT) CryptoPunk</a> è stato solo uno stratagemma di marketing NFT. In sostanza, l’NFT è stato venduto il 3 ottobre utilizzando un prestito lampo.</p>
<p>I dati on-chain mostrano che l’acquirente ha utilizzato un flash loan da <a href="/price/balancer-bal" rel="nofollow noopener noreferrer" target="_blank">Balancer</a> Protocol - un creatore di mercato automatizzato (AMM) - per acquistare l’NFT. Dopo che la transazione di vendita dell’NFT è stata completata, il portafoglio del venditore ha restituito i 24.000 ETH a <a href="/price/balancer-bal" rel="nofollow noopener noreferrer" target="_blank">Balancer</a>. In realtà, ciò dimostra che la vendita non era genuina. È stato solo un caso di passaggio dell’NFT da un indirizzo del portafoglio all’altro. L’acquirente ha utilizzato solo $54 che era la commissione di gas per le transazioni criptate in quel momento. Poiché <a href="https://www.gate.io/nft/collection/19626/Crypto---Punk" target="_blank">CryptoPunk 1563</a> è stato acquistato per $69,000 a settembre non c’è motivo per cui il suo valore potrebbe essere aumentato dell’81,000% in poche settimane. Per rendere le cose ancora peggiori, l’NFT non ha attributi rari che giustifichino una così alta crescita di prezzo in un breve periodo di tempo.<br><img src="https://gimg2.gateimg.com/image/article/17290466441.jpeg" alt=""><br>CryptoPunk 1563 Venduto per 24.000 ETH - x.com/Cryptopunksbot</p>
<p>24.000 ETH si è rivelato essere la cifra più alta pagata per un CryptoPunk NFT, anche durante la mania degli NFT nel febbraio 2022. Tuttavia, CryptoPunk 1563 non è stato il primo NFT ad essere acquistato utilizzando prestiti flash. Ad esempio, nel ottobre 2021 qualcuno ha utilizzato un prestito flash per acquisire un altro CryptoPunk 9998 del valore di $532 milioni in quel momento. Tuttavia, molte persone hanno considerato quella transazione falsa. Anche Larva Labs, il creatore di CryptoPunk, ha dichiarato che non avrebbe tracciato la vendita poiché non era legittima.</p>
<p>Commentando sulla transazione, <a href="https://x.com/cryptopunksnfts/status/1453903818308083720" rel="nofollow noopener noreferrer" target="_blank">Larva Labs ha detto</a>“, “Questa transazione (e molte altre) non è un bug o uno sfruttamento, ma è stata fatta con i “Flash Loans” In poche parole, qualcuno ha comprato questo punk da se stesso con denaro preso in prestito e ha restituito il prestito nella stessa transazione.” Tuttavia, Etherscan ha registrato quella transazione, qualcosa che confonderebbe molte persone.<br><img src="https://gimg2.gateimg.com/image/article/17290467032.jpeg" alt=""><br>Transazione confermata da Etherscan per Punk 9998 - x.com/Cryptopunksbot</p>
<h2 id="h2-Il20vero20motivo20dietro20al20trucco20CryptoPunk20156320NFT20Un20trucco20di20marketing795085"><a name="Il vero motivo dietro al trucco CryptoPunk 1563 NFT: Un trucco di marketing" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il vero motivo dietro al trucco CryptoPunk 1563 NFT: Un trucco di marketing</h2><p>Non è stata data una chiara ragione per la recente vendita di CryptoPunk 1563 utilizzando un prestito flash. Tuttavia, alcuni analisti hanno suggerito che potrebbe essere stata una trovata di marketing. Alcuni sostengono che la messa in scena NFT sia stata effettuata per prepararsi ad una prossima moneta meme chiamata Kamala Harris Punk. Pertanto, la vendita NFT potrebbe essere stata un mezzo per cercare supporto per la commercializzazione della moneta meme. Lo scaltro pseudonimo 0XQuit ha commentato su questo. <a href="https://x.com/0xQuit/status/1841945533453369807" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>, ‘Questa volta sembra essere un tentativo di marketing di una memecoin Kamala Harris Punks. Il contratto B in questo caso è un token ERC20 appena distribuito chiamato Kamala Harris Punk, che ha una prevendita aperta per circa 1 settimana.’</p>
<p>Tuttavia, 0XQuit ha detto che l’NFT in questione sarà venduto all’offerta più alta dopo una prevendita di una settimana. Il risultato della vendita potrebbe andare in entrambi i modi - un profitto o una perdita.<br><img src="https://gimg2.gateimg.com/image/article/17290467893.jpeg" alt=""><br>La via da seguire dopo lo stunt NFT - x.com/Quit</p>
<h2 id="h2-Analisi20del20mercato20NFT2020NFT20di20alto20valore20legittimo397627"><a name="Analisi del mercato NFT - NFT di alto valore legittimo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analisi del mercato NFT - NFT di alto valore legittimo</h2><p>Ci sono <a href="https://www.gate.io/learn/articles/what-are-the-main-nft-collections/934" target="_blank">molti NFT sul mercato al momento</a>. Tuttavia, alcuni di essi non hanno più alcun valore. CryptoPunks sono tra gli NFT altamente preziosi e legittimi sul mercato. Ad esempio, CryptoPunk n. 2386, acquistato per 10 ETH, vale ora circa 600 ETH (circa 1,5 milioni di dollari). Tuttavia, è stato dimenticato e trascurato per un lungo periodo. Negli ultimi mesi e mezzo, sono stati venduti CryptoPunks per un valore totale di 16,7 milioni di dollari.</p>
<p>Liberty Cats, ospitato su <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, sono anche legittimi. Di conseguenza, durante gli ultimi tre mesi, i Liberty Cats hanno registrato un volume di trading di oltre $157,86 milioni. La collezione NFT è ancora richiesta dopo aver registrato 3.010 transazioni dal loro lancio durante il Q3 del 2024. Il Bored Ape Yacht Club <a href="https://www.gate.io/learn/articles/what-is-bored-ape-yacht-club/143" target="_blank">(BAYC)</a> è una delle <a href="https://www.gate.io/nft/collection/9163/BAYC" target="_blank">set di NFT più amati</a> Durante gli ultimi tre mesi sono stati coniati più di 10.000 NFT di immagini del profilo su. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> blockchain. Hanno avuto un volume totale di trading NFT di 15,1K ETH. Anche la collezione BAYC è molto apprezzata nel settore NFT. Il loro ruolo pionieristico nel profilo immagine (PFP) NFT ha portato alla loro elevata domanda.</p>
<p>E, in effetti, <a href="https://www.gate.io/learn/articles/all-you-need-to-know-about-pudgy-penguins/1756" target="_blank">Pinguini paffuti, con 8.888 avatar di pinguino generativi</a>, sviluppato dallo studio NFT Igloo su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, sono anche una collezione di preziosi NFT. Durante l’ultimo trimestre hanno avuto un volume di scambi di 14,67K ETH.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog/1524/rarest-pudgy-penguin-fetches-400-eth" target="_blank">Il Pudgy Penguin più raro si vende a 400 ETH</a></p>
<h2 id="h2-Rischi20e20conseguenze20della20manipolazione20nel20mercato20NFT770450"><a name="Rischi e conseguenze della manipolazione nel mercato NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rischi e conseguenze della manipolazione nel mercato NFT</h2><p>La manipolazione del mercato si verifica quando alcuni investitori utilizzano mezzi ingannevoli per gonfiare i valori degli asset prima di venderli. In alcuni casi, i trader possono utilizzare modi fraudolenti per far diminuire i valori degli asset come gli NFT prima di acquisirli. Ci sono varie tattiche che i trader fraudolenti possono utilizzare come spoofing, front running, wash trading, insider trading e schemi di pump &amp; dump. Un modo popolare per manipolare il mercato è utilizzare celebrità pagate per promuovere un NFT. Una volta che il valore dell’NFT è salito a un certo livello, il trader prende tutti i profitti e scarica l’asset.</p>
<p>Senza dubbio, la manipolazione del mercato influenza negativamente il mercato NFT. Potrebbe rendere possibile che i NFT guadagnino molta legittimità. Alcuni dei NFT il cui prezzo potrebbe essere stato manipolato potrebbero perdere valore in modo permanente. Inoltre, le oscillazioni di prezzo associate alla manipolazione del mercato potrebbero scoraggiare alcuni investitori dall’investire in NFT e altri asset digitali. In generale, la manipolazione del mercato nel settore digitale potrebbe portare alla perdita di fiducia e di fiducia degli investitori in asset virtuali.</p>
<p>Leggi anche: <a href="https://www.gate.io/web3/nft" target="_blank">Scopri i prossimi NFT più grandi in Web3</a></p>
<h2 id="h2-Lo20stato20attuale20del20mercato20NFT501958"><a name="Lo stato attuale del mercato NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo stato attuale del mercato NFT</h2><p>Per la maggior parte del 2024 il mercato degli NFT è stato in una montagna russa fino al quarto trimestre, dove ci sono segnali di ripresa del mercato. Il volume di trading degli NFT trimestrale è diminuito di circa il 50% durante il Q3 a 1,1 miliardi di dollari. Fondamentalmente, l’anno è iniziato con un volume totale di mercato degli NFT di 4,1 miliardi di dollari. Da lì è sceso a 2,25 miliardi di dollari nel Q2 prima di scivolare ulteriormente al livello attuale. Tuttavia, gli ultimi dati da … <a href="https://www.cryptoslam.io/nftglobal?timeFrame=year&amp;headerPeriod=7d" rel="nofollow noopener noreferrer" target="_blank">CryptoSlam</a> mostra che il declino del mercato NFT sta continuando. Ad esempio, durante gli ultimi 30 giorni le vendite totali di NFT ammontavano a circa 333 milioni di dollari. Il grafico seguente riassume le principali tendenze di trading.<br><img src="https://gimg2.gateimg.com/image/article/17290470184.jpeg" alt=""><br>Vendite annuali di NFT - CryptoSlam</p>
<p>Come <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">il grafico</a> mostra che c’è stato un aumento degli acquirenti unici durante l’ultimo anno. Tuttavia, c’è stato un calo delle vendite totali e dei venditori unici. Nel complesso, il mercato NFT ha dimostrato resilienza di fronte a diverse sfide, tra cui le attuali condizioni economiche globali e le guerre in corso in Ucraina e Medio Oriente.</p>
<h2 id="h2-Il20Futuro20degli20NFT20e20la20Trasparenza20della20Blockchain195426"><a name="Il Futuro degli NFT e la Trasparenza della Blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il Futuro degli NFT e la Trasparenza della Blockchain</h2><p>Il futuro degli NFT è avvolto nell’incertezza a causa di diversi fattori che includono i cambiamenti normativi. Al momento, l’entusiasmo iniziale che circondava gli NFT si è dissolto e solo gli appassionati di NFT sono rimasti concentrati. Oltre alle sfide economiche che la maggior parte dei paesi sta affrontando, l’aumento delle truffe e di altre attività illegali ha portato al livello di <a href="https://www.gate.io/blog/1250/nfts-market-value-reduces-by-over-90-after-crypto-crash" target="_blank">interesse per NFT in calo</a>. Negli Stati Uniti la SEC sta prendendo provvedimenti per regolamentare il settore NFT poiché ha dichiarato che gli NFT sono titoli.</p>
<p>Articolo correlato: <a href="https://www.gate.io/blog/1275/why-many-crypto-assets-are-falling" target="_blank">Perché molti asset crittografici stanno cadendo</a></p>
<p>Nonostante lo stato attuale del mercato NFT, nuovi sviluppi potrebbero riposizionarli per la crescita. Ad esempio, l’emergere di nuovi casi d’uso potrebbe accendere un interesse sostenibile nei token. Gli NFT potrebbero avere un ruolo da giocare in diversi settori dell’economia, tra cui l’istruzione, l’immobiliare e il gaming. L’altra cosa che probabilmente aumenterà l’adozione degli NFT è l’interoperabilità. In altre parole, gli NFT utilizzabili su diverse piattaforme avranno più utilità rispetto a quelli basati su una singola piattaforma.</p>
<p>Il miglioramento della trasparenza della blockchain potrebbe anche aiutare a creare fiducia nel mercato NFT. Ad esempio, i protocolli blockchain che gestiscono gli NFT dovrebbero garantire che non vi sia spazio per attività fraudolente o asset contraffatti. Inoltre, dovrebbero assicurarsi che non vi siano attività fraudolente sulle loro piattaforme. Un altro aspetto essenziale che può aumentare l’adozione di NFT è la giusta compensazione per i creatori. Ad esempio, dovrebbe esserci un mezzo chiaro … <a href="https://www.gate.io/learn/articles/how-nft-royalties-work-designs-challenges-and-new-ideas/3624" target="_blank">di tracciamento dei diritti d’autore per gli NFT</a>.</p>
<h2 id="h2-Conclusion351626"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Il 1 ottobre un investitore di NFT ha utilizzato un flash loan per acquistare CryptoPunk 1563 per 24.000 ETH. Tuttavia, il prezzo di acquisto elevato ha creato dubbi tra la comunità dei NFT poiché il token era valutato a $69.000 a settembre. Alla fine è stato stabilito che la vendita non era legittima. Nel frattempo, dal 2024 c’è stata una forte diminuzione del valore dei NFT. Un modo in cui l’interesse per i NFT potrebbe essere riaccendere è l’introduzione di nuovi casi d’uso.</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. Tutti gli investimenti comportano rischi intrinseci; è essenziale prendere decisioni prudenti.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>