TmVsIDIwMjUsIGxhIEJsb2NrY2hhaW4gQ29tbXVuaXR5IGhhIHNjb3BlcnRvIHVuIHNvc3BldHRvIGNhc28gZGkgZnJvZGUgbmVsbFwnZW1pc3Npb25lIGRpIE5GVCBkZWwgdmFsb3JlIGRpIDIwIG1pbGlvbmkgZGkgZG9sbGFyaS4=

2022-03-14, 06:09

<p><img src="https://gimg2.gateimg.com/image/23202506061516220034923324.jpg" alt="">
</p><h2 id="h2-Ultimi20sviluppi20nel202025702832"><a name="Ultimi sviluppi nel 2025" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ultimi sviluppi nel 2025</h2><hr>
<p>In un significativo sviluppo dopo lo scandalo degli NFT Squiggles, una società di forense blockchain ha implementato un sistema di rilevamento avanzato specificamente progettato per identificare le reti di portafogli ombra. Questi sistemi sono ora in grado di contrassegnare schemi di transazione sospetti su più piattaforme prima che le truffe raggiungano una scala critica.</p>
<p>I dati delle aziende di analisi blockchain mostrano significativi miglioramenti nella rilevazione delle frodi:</p>
<table>
<thead>
<tr>
<th>Indicatore</th>
<th>2023</th>
<th>2025</th>
</tr>
</thead>
<tbody>
<tr>
<td>Tempo medio di rilevamento</td>
<td>72 ore</td>
<td>8,5 ore</td>
</tr>
<tr>
<td>Tasso di Recupero</td>
<td>12%</td>
<td>37%</td>
</tr>
<tr>
<td>Tasso preventivo</td>
<td>24%</td>
<td>68%</td>
</tr>
</tbody>
</table>
<p>L’organizzazione NFT Factory esposta da Coffeezilla è stata permanentemente messa al bando su tutte le principali piattaforme, e le loro impronte digitali sono ora tracciate da algoritmi specializzati. I team di sicurezza delle piattaforme condividono informazioni attraverso un sistema di allerta decentralizzato per combattere congiuntamente i gruppi di frode organizzata.</p>
<p>I regolatori hanno stabilito protocolli di verifica standardizzati per i progetti NFT di alto valore, richiedendo verifiche dell’identità in più fasi e dichiarazioni sulla provenienza dei fondi prima che i progetti che superano soglie specifiche vengano lanciati.</p>
<p>Queste misure di protezione rappresentano una significativa evoluzione dell’infrastruttura di sicurezza blockchain, dimostrando come l’ecosistema si adatti e migliori dopo tentativi di truffa di alto profilo come Squiggles.</p>
<h2 id="h2-La20comunit20blockchain20smantella20un20presunto20scam20di20airdrop20NFT20da202020milioni20di20dollari433428"><a name="La comunità blockchain smantella un presunto scam di airdrop NFT da 20 milioni di dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La comunità blockchain smantella un presunto scam di airdrop NFT da 20 milioni di dollari</h2><h2 id="h2-Abstract378833"><a name="Abstract" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Abstract</h2><hr>
<p>Il popolare YouTuber Coffeezilla ha scoperto una truffa di airdrop NFT da 20 milioni di dollari. Il <a href="https://www.youtube.com/watch?v=PbBft8SPpCA" rel="nofollow noopener noreferrer" target="_blank">YouTube</a> L’influencer ha rivelato questa frode in un recente video su YouTube.</p>
<p>Hanno in programma di utilizzare un progetto NFT chiamato Squiggles per crearne hype. Tuttavia, solo poche ore prima del rilascio di Squiggles, un file è stato cancellato e l’intero team dietro il progetto è stato accusato. Secondo il file, il team dietro Squiggles è un gruppo di individui responsabili di molteplici truffe, e il progetto Squiggles è in realtà solo una marionetta. Secondo la rivelazione di Coffeezilla, questi truffatori sono chiamati fabbriche di NFT. Dalla scoperta, OpenSea ha rimosso il progetto di truffa NFT airdrop. Anche i portafogli shadow utilizzati per promuovere narrazioni false sono stati esposti e rimossi da OpenSea.</p>
<p><a href="https://www.gate/cn/questionnaire/1521" rel="nofollow noopener noreferrer" target="_blank"><em>Compila il modulo per ricevere 5 schede punti →</em></a></p>
<h2 id="h2-La20storia20dietro20Squiggles433119"><a name="La storia dietro Squiggles" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La storia dietro Squiggles</h2><hr>
<p>Il 10 febbraio, il nuovo progetto NFT Squiggles ha iniziato a coniare. Secondo gli sviluppatori, il progetto è una collezione di 10.000 NFT. Prima del lancio della serie, c’era molta attesa attorno al progetto, con il team che ha speso una somma significativa di denaro per la promozione, inclusi cartelloni elettronici e assunzione di influencer. L’account Twitter di Squiggles ha attualmente circa 223.000 follower, mentre poco prima dell’esposizione delle sue attività fraudolente, aveva raggiunto 230.000 follower.</p>
<p>Tuttavia, solo poche ore prima del lancio del progetto, è circolato un video criminale che rivelava Arsalan, la vera identità dietro la truffa, che ha portato infine al suo fallimento. Secondo Coffeezilla, qualcuno ha visto Arsalan nella stessa auto di un altro sospetto truffatore NFT, Gavin. Gavin Mayo è una figura nota per i suoi rug pull NFT ed è stato messo nella lista nera dalla comunità NFT.</p>
<p>Homepage delle Anime Peccaminose</p>
<p>Dopo aver collegato una serie di eventi correlati e ulteriori indagini, Coffeezilla<br>ha prodotto un video completo sulle attività del progetto su Opensea. <a href="https://www.gate/cn/bitwiki/detail/727" rel="nofollow noopener noreferrer" target="_blank">Truffa del Carpet Pull</a> Sono state fornite prove sufficienti. Queste indagini includono il monitoraggio degli account di Etherscan coinvolti nelle fasi iniziali del progetto.</p>
<p>Meno di 30 minuti dopo il lancio del progetto, erano stati venduti Squiggles per un valore di circa 7 milioni di dollari. A seguito di ulteriori indagini, è stato scoperto che un wallet ombra creato da un account aveva speso circa 500 ETH per il progetto. Un altro account è stato scoperto aver acquistato 800 ETH utilizzando un wallet ombra. Entrambi gli account hanno comprato Squiggles e hanno cercato di vendere gli NFT a un prezzo inferiore su OpenSea. Secondo Coffeezilla, questo comportamento era volto a creare un effetto di hype per Squiggles e a speculare. Vendere opere d’arte NFT a un prezzo inferiore su OpenSea è inteso a creare l’illusione che ci sia un’alta domanda e buone vendite per questa serie di NFT. Tuttavia, prima che potessero portare a termine la loro truffa, OpenSea ha rimosso la serie Squiggles insieme ai wallet ombra.</p>
<h2 id="h2-Squiggles20sta20ancora20combattendo944781"><a name="Squiggles sta ancora combattendo." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Squiggles sta ancora combattendo.</h2><hr>
<p>Date le prove solide, la gente pensava che il team avrebbe annullato il progetto. Tuttavia, poche ore dopo il lancio del progetto, Arsalan ha dichiarato in un post su Instagram:</p>
<p>“Ho appena scoperto alcune osservazioni folli su di me e alcune strane accuse, senza sapere su quale base si fondino o come io sia rimasto coinvolto in tutto ciò. Fisicamente, finanziariamente o mentalmente, non farei mai del male a nessuno; non sono questo tipo di persona; i miei valori morali sono molto retti.”</p>
<p>Per dimostrare che le sue azioni non erano illegali la notte prima del lancio del progetto, Arsalan ha ulteriormente spiegato:</p>
<p>“Queste persone stanno cercando di distorcere i fatti e incitare paura. I miei amici ed io eravamo in discoteca, semplicemente perché i miei amici hanno una cattiva reputazione in questo campo. Ora cercano di collegarmi a loro; ragazzi, non è così. Per favore, non saltate alle conclusioni.”</p>
<p>Nonostante tutto stia fallendo, Arsalan sta ancora tenendo incontri con i possessori di Squiggles e i membri della whitelist. Il team dietro il progetto sta anche cercando di lanciare una campagna sui social media con l’hashtag #freesquiggles per convincere Opensea a rilistare il progetto. Il progetto è attualmente attivo su Looksrare, e oltre 2.700 pezzi della collezione sono in vendita. Hanno annunciato nel loro comunicato stampa su Twitter che ridurranno la collezione a 5.000 pezzi.</p>
<p><a href="https://twitter.com/squiggles/status/1494862290042056706" rel="nofollow noopener noreferrer" target="_blank">Twitter Press\<br>\<br>Rilascia</a></p><a href="https://twitter.com/squiggles/status/1494862290042056706" rel="nofollow noopener noreferrer" target="_blank">
</a><h2 id="h2-Il20team20dietro20Squiggles2020stato20accusato20di20altre20frodi855274"><a href="https://twitter.com/squiggles/status/1494862290042056706" rel="nofollow noopener noreferrer" target="_blank"></a><a name="Il team dietro Squiggles è stato accusato di altre frodi." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il team dietro Squiggles è stato accusato di altre frodi.</h2><hr>
<p>Il documento di oltre 60 pagine rilasciato poche ore prima del lancio del progetto ha messo Squiggles nei guai. Il documento sostiene che Arsalan sia solo il capo nominale dello schema di truffa NFT, mentre il vero cervello è Squiggles. Secondo i documenti, c’è un team di truffatori NFT dietro al progetto, e questo gruppo di fraudatori è anche responsabile di altri schemi di truffa NFT.</p>
<p>Nel video di Coffeezilla, le identità di tre individui (nomi non specificati) sono i team dietro League of Sacred Devils, League of Divine Beings, Vault of Gems, Sinful Souls, Dirty Dogs, Lucky Buddhas, Uncovered, Faceless e altri. Secondo lui, questi individui migliorano la creazione di truffe NFT massproducendo progetti NFT che sembrano di alta qualità ma sono semplicemente facciate. Implementano la truffa facendo da prestanome per ciascun progetto NFT sotto diverse sembianze. Tuttavia, il genio dietro tutte queste azioni è la stessa persona.</p>
<p>Due membri della truffa, Gavin Mayo e Travis Skiver, hanno ammesso in un video di essere i cervelli dietro Sinful Souls. Tuttavia, il manipolatore dietro Faceless, Travis Skiver, ha negato di essere mai stato dietro Sinful Souls. Faceless ha causato una sensazione su YouTube. <a href="https://www.youtube.com/watch?v=p2lSAVbsJZE" rel="nofollow noopener noreferrer" target="_blank">NFT Inspector</a> Si crede che Faceless abbia rubato una collezione di opere d’arte digitali, reprimendo così questa attività criminale.</p>
<p>I truffatori discussi in una serie di documenti trapelati chi sarebbe diventato il leader del nuovo progetto. Un messaggio indica che il membro della gang Gabe “è chiaramente il capitano”; tuttavia, sul sito web Faceless, Travis è definito “il capitano”. Le notizie suggeriscono che Squiggles ha venduto circa 2.700 NFT falsi Sinful Souls prima di andare offline, guadagnando quasi $500.000. L’indagine ha rivelato come l’organizzazione cercasse di organizzarsi. Ad esempio, è stata tenuta un’esposizione di Sinful Souls in una location a Los Angeles, rivendicando la sua legittimità, il che ha portato molti a diventare vittime. Gavin ha dichiarato che l’organizzazione si è persino sviluppata al punto di aprire un ufficio fisico, dove uno dei leader ha detto: “in questo modo il team non sarà disordinato.”</p>
<p>I truffatori sono riusciti a guadagnare circa 20 milioni di dollari dallo schema di airdrop NFT Squiggles prima di essere smascherati. Fortunatamente, le loro azioni sono state rivelate, impedendo a migliaia di persone di diventare vittime del loro trucco.</p>
<div class="blog-details-info"><br>  <div>Autore: Team del Blog<br>  <div class="info-tips"><em>Questo contenuto non costituisce alcuna offerta, sollecitazione o suggerimento. Dovresti sempre cercare un consiglio professionale indipendente prima di prendere qualsiasi decisione di investimento.<br><div></div>Si prega di notare che Gate potrebbe limitare o vietare tutti o parte dei suoi servizi da aree restrette. Si prega di leggere il contratto utente per ulteriori informazioni, link:<a  rel="nofollow noopener noreferrer"  href="https://www.gate/zh/user-agreement。" data-index="6"></a><a  rel="nofollow noopener noreferrer"  href="https://www.gate/en/user-agreement" data-index="7">https://www.gate/en/user-agreement</a>.<br><p></p><br></em></div></div></div>