RXNhbWluYW5kbyBsJ2FzY2VzYSBkaSBQRVBFIGRhbGwnaW5pemlvIGFsbGEgZmluZSBkZWwgY3JvbGxv

2023-08-30, 03:00

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""><br>Simile alla nascita di <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> L’emergere di PEPE ha un’impronta culturale distintamente europea e americana.</p>
<p>Il prototipo della moneta PEPE è Pepe the Frog, una rana cartone animato ribelle creata da Steve Repetti e dal suo team nel 2016.</p>
<p>Poiché l’immagine divenne un design aperto, ha ottenuto una trasmissione virale su piattaforme come 4chan e Tumblr, e molti gruppi di destra su Internet hanno iniziato a utilizzare questa immagine per esportare odio e razzismo.<br><img src="https://gimg2.gateimg.com/image/article/16933769307861693364034_.pic_hd.jpg" alt=""><br>Fonte dell’immagine: informazioni pubbliche online</p>
<p>Per ridisegnare l’immagine positiva di Pepe the Frog, il team di PEPE ha progettato una serie di nuove carte e creato le monete PEPE. Questa immagine semplice e interessante è stata rapidamente accettata dalla comunità cripto, e la combinazione di simboli culturali e tecnologia digitale ha ottenuto rapidamente una diffusione inaspettata.</p>
<h2 id="h2-Una20Frenesia20di20Mercato20Scatenata20da20Una20Rana717757"><a name="Una Frenesia di Mercato Scatenata da Una Rana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Una Frenesia di Mercato Scatenata da Una Rana</h2><p>La popolarità di PEPE è senza precedenti nel campo dei MEME.</p>
<p>Il team di sviluppo anonimo delle monete PEPE ha rilasciato i PEPEs il 14 aprile, con un’offerta totale di 4,2069 milioni, la maggior parte dei quali è stata depositata in <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> Il 93,1% sono stati immessi nel pool di liquidità di Gate.io e il restante 6,9% è stato conservato in portafogli multi-firma.</p>
<p>Successivamente il team ha creato un’attività MEME semplice su Twitter, incoraggiando tutti a utilizzare PEPE per la comunicazione e l’interazione sui social media, nei giochi e in altre applicazioni online. Nei giorni successivi, il numero dei possessori di monete è rapidamente salito di migliaia, e il 5 maggio il loro valore di mercato ha superato 1.8 miliardi di dollari.</p>
<p>La moneta PEPE è rapidamente scesa del 50% dopo aver mostrato la sua forza nell’industria. Tuttavia, prima che gli investitori potessero riprendersi dalle loro perdite, i KOL e gli scambi, che erano ancora più sollecitati, hanno nuovamente acceso l’entusiasmo della comunità per MEME.</p>
<p>Il 13 maggio, Musk ha twittato per un singolo ordine di PEPE, e PEPE è immediatamente salito di circa il 10%, con un aumento del 50% nelle ultime 24 ore.<br><img src="https://gimg2.gateimg.com/image/article/16933769877871693364057_.pic_hd.jpg" alt=""><br>Fonte dell’immagine: Twitter</p>
<p>Sebbene molti analisti abbiano avvertito gli investitori che subiranno perdite nella speculazione sulle monete MEME, la follia di PEPE non si è fermata e gli investitori entusiasti continuano ad affluire. Il valore di mercato di PEPE è diventato una volta la terza più grande moneta MEME dopo DOGE e SHIBA.</p>
<h2 id="h2-Un20dramma20di20incidenti20complesso20e20confuso981663"><a name="Un dramma di incidenti complesso e confuso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Un dramma di incidenti complesso e confuso</h2><p>Dopo che il mercato delle criptovalute è entrato in luglio, è caduto in un mercato lungo e noioso. Con il calo del calore speculativo e il rallentamento del mercato, PEPE ha inevitabilmente avviato una profonda correzione.</p>
<p>Alla fine di agosto, PEPE, che era stato silenzioso per molti giorni, ha fatto grandi notizie.</p>
<p>Secondo un membro del team, i token del portafoglio multi-firma detenuti dal team sono stati rubati, e tre ex membri del team sono tornati di nascosto e hanno rubato i token dal portafoglio. Sono stati accusati di vendere 16 trilioni di token PEPE all’exchange.</p>
<p>Un’evidenza ovvia è che il portafoglio multi-firma PEPE ha improvvisamente cambiato la soglia da5⁄8a2⁄8, consentendo solo a due titolari di chiavi private di trasferire senza problemi i token rimanenti.</p>
<p>Dopo l’evento, PEPE è crollato del 20% in breve tempo.</p>
<p>Il team di PEPE ha prontamente chiarito su Twitter ufficiale che ha adottato misure per eliminare le dispute interne e sta pianificando l’acquisto di nomi di dominio PEPE con i token rimanenti, che verranno distrutti in futuro.</p>
<p>Ma questa spiegazione non sembra risolvere la crisi di fiducia della comunità, e il fondatore di CryptoPhunks, Paul, ha rivelato con rabbia lo sfondo del fondatore di PEPE.</p>
<p>Secondo Paul, Zachary Testa è l’operatore dietro le quinte dei token PEPE. È nato in Arizona nel 1997 ed è un fotografo paesaggista bannato più volte. Ha acquistato un Lamborghini viola del valore di $865,000 con i proventi dei token $pepe emessi, ma lui e il suo team non hanno mai pagato alcuna tassa a Matt Furie, il creatore originale di Pepe the Frog.<br><img src="https://gimg2.gateimg.com/image/article/16933770437881693364075_.pic_hd.jpg" alt=""><br>Fonte dell’immagine: Twitter</p>
<p>Una serie di eventi hanno causato il prezzo di PEPE a toccare nuovi minimi, ma ci sono sempre rischi e opportunità amplificate nel mondo dei MEME. Secondo i dati di IntoTheBlock, il volume di trading su PEPE è aumentato notevolmente. Mentre alcuni utenti hanno abbandonato PEPE, altre balene sembrano aver iniziato ad entrare nel mercato in una fase di ribasso, e il festino di PEPE sembra non essere ancora finito.</p>
<h2 id="h2-Conclusion949497"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Coincidentalmente, i token PEPE sono nati a causa della loro immagine ribelle e interessante di rana. Hanno rapidamente guadagnato popolarità grazie al loro gioco semplice e senza cervello, hanno scatenato l’effetto FOMO a causa dell’hype sociale e sono caduti sull’altare a causa di dispute di interesse interne, diventando un’altra leggendaria storia del mercato cripto.</p>
<p>Sullo sfondo dell’attuale mercato orso-toro, l’emergere di PEPE ha scatenato una frenesia per MEME per creare ricchezza. La crescita parabolica e la traiettoria discendente dei prezzi delle criptovalute riflettono il gioco psicologico tra utenti e speculatori.</p>
<p>Se gli speculatori a breve termine sono adatti a partecipare a questa frenesia centuplicata, allora PEPE potrebbe non essere la scelta migliore per gli investitori di fronte ai vari giochi di fondi e agli eventi scioccanti che spesso sono disorientanti.</p>
<p>In ogni caso, nel complesso mercato delle criptovalute, ciò che è ancora importante per gli investitori è DYOR.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Peter G.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<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 relativi a questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione Gate.io sia referenziato. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>