TGEgY2F1c2EgZGkgY2xhc3NlIG1vZGlmaWNhdGEgYWZmZXJtYSBjaGUgRWxvbiBNdXNrIGFiYmlhIGNvbW1lc3NvIGluc2lkZXIgdHJhZGluZyBjb24gRG9nZWNvaW4=

2023-06-14, 03:39

<p><img src="https://gimg2.gateimg.com/image/article/1684401663RDZZ.jpeg" alt=""><br>Il querelante nel caso di insider trading di Musk ha richiesto il permesso di emendare una class action con l’intenzione di aggiungere nuove accuse.</p>
<p>Gli investitori di <a href="/price/dogecoin-doge" target="_blank" class="blog_inner_link">Dogecoin</a> che stanno citando in giudizio Musk affermano che ha manipolato il prezzo della criptovaluta per trarne vantaggio dalle sue variazioni di prezzo a breve termine.</p>
<p>Musk e il suo team legale non hanno commentato l’azione degli investitori di Dogecoin che hanno richiesto di modificare una causa collettiva.</p>
<p>Parole chiave: CEO di Twitter, Elon Musk, causa criptata, cripto Doge, Dogecoin, trading Doge, modifica del registro di Twitter, investitori di Dogecoin</p>
<h2 id="h2-Introduzione465791"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Durante i primi giorni delle criptovalute, non c’erano quasi azioni legali nei confronti di singoli e istituzioni crypto come gli scambi. Tuttavia, al momento, singoli e agenzie governative negli Stati Uniti e in alcuni altri paesi stanno intraprendendo azioni contro potenziali trasgressori. In questo articolo, parleremo di una causa legale contro Elon Musk.</p>
<h2 id="h2-Class20Action20modificata20contro20Elon20Musk196457"><a name="Class Action modificata contro Elon Musk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Class Action modificata contro Elon Musk</h2><p>Un gruppo di investitori di Dogecoin che ha citato in giudizio Elon Musk, l’ex CEO di Twitter, ha richiesto di modificare una causa collettiva nei suoi confronti con l’accusa di manipolazione della <a href="https://www.gate.io/price/dogecoin-doge" target="_blank">prezzo di Dogecoin</a> per il suo beneficio personale e quello della sua azienda Tesla Inc.</p>
<p>Inizialmente gli investitori hanno presentato una causa legale contro Musk nel giugno 2022 dopo l’infame apparizione di Musk al Saturday Night Live a cui ha partecipato prima di assumere il controllo di Twitter. Tuttavia, aveva già mostrato <a href="https://www.gate.io/blog_detail/2507/dogecoin-mask-returns-twitter-logo" target="_blank">molto interesse nella promozione di Dogecoin</a>, uno dei principali memecoins, sui social media, in particolare su Twitter. Finora, i querelanti hanno modificato la causa legale due volte a seguito delle azioni di Musk e dei dettagli emergenti.<br><img src="https://gimg2.gateimg.com/image/article/16867137941.png" alt=""><br>Elon Musk- NYtimes</p>
<p>Il 31 maggio di quest’anno, il gruppo di investitori ha presentato la propria causa contro Musk presso la Corte distrettuale degli Stati Uniti per il distretto meridionale di New York, sostenendo che Musk ha utilizzato il suo grande seguito su Twitter e altri media pubblici per trarre profitto dalle operazioni di Dogecoin attraverso quella che hanno definito una manipolazione del mercato delle criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/price-prediction/dogecoin-doge &quot;Dogecoin (DOGE" rel="nofollow noopener noreferrer" target="_blank">Previsione del prezzo di Dogecoin (DOGE) 2023-2030</a> Previsione del prezzo 2023-2030”)</p>
<p>Hanno dichiarato che se non fosse stato per le “affermazioni materiali erronee e le omissioni di Musk, i ricorrenti e la classe non avrebbero acquistato Dogecoin.”<br><strong>Hanno suggerito che Tesla e Musk siano stati “ingiustamente arricchiti di miliardi di dollari” a seguito di “vendite non dichiarate di <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> basato su informazioni riservate.</strong>”</p>
<p>Inoltre, il querelante ha affermato che Musk ‘ha assunto una responsabilità estesa per l’azienda Dogecoin nel suo complesso, dando così vita al rapporto fiduciario necessario per avanzare una richiesta di insider trading.’</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2236/doge-floki-soar-musk-tweets-photo-dog-twitter-ceo-chair" target="_blank">Doge, Floki Soar dopo che Musk ha tweettato la foto del suo cane sulla sedia del CEO di Twitter</a></p>
<p>Inoltre, hanno affermato che Musk ha rappresentato in modo errato le informazioni quando ha dichiarato che la sua azienda, SpaceX, avrebbe mandato il prezzo di Dogecoin sulla luna, cosa che non è avvenuta.</p>
<p>Successivamente, gli investitori <a href="https://edition.cnn.com/2023/04/27/tech/elon-musk-twitter-six-months/index.html" rel="nofollow noopener noreferrer" target="_blank">ha affermato che Elon Musk</a> ha iniziato a utilizzare Twitter per influenzare i prezzi di diverse criptovalute tra cui <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> e Dogecoin nel 2019. Oltre all’accusa che Musk fosse coinvolto in insider trading di Doge crypto, sostengono anche che Doge sia un titolo, basato sul Test di Howey.</p>
<p>Di conseguenza, la causa riformulata afferma: “Si tratta di un’azione collettiva per frode sui titoli derivante da un corso deliberato di manipolazione del mercato attraverso l’utilizzo di pratiche truffaldine e insider trading condotte dal più ricco uomo del mondo, Elon Musk, che ha sequestrato un emergente fenomeno della cultura popolare per promuovere se stesso e le sue aziende, e per gonfiare la sua fortuna oscena, sfruttando le speranze sincere degli americani vulnerabili, tra cui i veterani di guerra, i lavoratori delle classi subalterne e gli anziani.”</p>
<p>Tuttavia, la SEC non ha confermato che il Dogecoin sia un titolo crittografico. Pertanto, non rientra tra le 68 criptovalute elencate dalla SEC come titoli crittografici.</p>
<p>Al momento di scrivere, Musk, uno dei più ricchi del mondo, non ha ancora risposto alle ultime accuse. L’altra lamentela, tuttavia, è che Twitter ha sostituito il suo iconico logo dell’uccello blu con l’immagine di <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> cane, che rappresenta Dogecoin, che ha portato a un aumento del 30% del valore della criptovaluta.</p>
<p>In modo simile, gli investitori di Dogecoin hanno anche affermato che Musk ha manipolato il prezzo di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> attraverso le sue attività sui social media in un momento in cui la sua azienda, Tesla, lo stava scambiando. Tuttavia, nella loro recente modifica hanno elencato solo Musk e Tesla come imputati in quanto hanno abbandonato la Dogecoin Foundation.</p>
<p>Il querelante ha sostenuto che “Musk ha scambiato Dogecoin in modo redditizio attraverso uno o più portafogli e scambi domestici utilizzando una conoscenza preventiva allora sconosciuta e non divulgata agli investitori di Dogecoin in generale o pubblicamente, delle sue mosse intenzionali per manipolare il mercato.”</p>
<p>Di conseguenza, i convenuti hanno il diritto di rispondere alle denunce modificate entro il 14 giugno 2023. Allo stato attuale, il tribunale è probabile che conceda l’autorizzazione richiesta per modificare una causa collettiva. Ciò perché in un documento separato il giudice Alvin Hellerstein ha affermato che “la richiesta dei querelanti di autorizzazione a presentare tale denuncia è probabile che venga accolta, poiché non ci sono probabilità di pregiudizio contro i convenuti di Tesla e l’autorizzazione a presentare una denuncia modificata viene liberamente concessa.” Risposta del Team Legale di Musk</p>
<p>Nel frattempo, il team legale di Musk ha confutato che Elon Musk abbia commesso attività fraudolente o abbia effettuato insider trading. Gli avvocati hanno affermato che il loro cliente non ha violato alcuna legge pubblicando alcuni meme e immagini.</p>
<p>Secondo loro ‘erano solo immagini divertenti su una criptovaluta legittima’. Aggiungono: ‘Si tratta di una criptovaluta legittima - anzi, una delle più grandi - che è valutata a quasi 10 miliardi di dollari’. Il loro argomento qui è che Dogecoin non è uno schema crypto ponzi come sostiene il querelante.</p>
<p>Inoltre, il 3 maggio hanno chiesto al tribunale di respingere la seconda denuncia emendata contro Musk. Tuttavia, non hanno ancora espresso la propria posizione sulla recente richiesta di modifica della causa collettiva.</p>
<h2 id="h2-Performance20di20Dogecoin20in20mezzo20alla20causa20in20corso406004"><a name="Performance di Dogecoin in mezzo alla causa in corso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Performance di Dogecoin in mezzo alla causa in corso</h2><p>Fondamentalmente, il prezzo del Dogecoin è rimasto piatto per gran parte del 2023, un periodo in cui la controversia tra Musk e gli investitori di Dogecoin è continuata. Il suo valore si è mantenuto tra $0.07 e $0.09 come indicato nel seguente diagramma.<br><img src="https://gimg2.gateimg.com/image/article/16867138932.png" alt=""><br>Prestazioni dei prezzi di Dogecoin nel 2023 - Statista</p>
<p>Come puoi vedere dal grafico sopra, <a href="https://www.gate.io/trade/DOGE_USDT" target="_blank">Doge stava scambiando al di sotto di $0.09</a> per la maggior parte del 2023. Al momento della scrittura è quotato a $0,621, circa il 91,51% in meno rispetto al suo massimo storico di $0,731 raggiunto l’8 maggio 2021.</p>
<h2 id="h2-Conclusione868033"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Alcuni investitori di Dogecoin continuano con la loro causa legale contro Musk per presunta manipolazione del prezzo di Doge attraverso le sue attività su Twitter e altri canali di comunicazione pubblica. Tuttavia, Musk e il suo team legale sostengono di non aver commesso nulla di illegale poiché ha pubblicato alcune immagini e commenti su una criptovaluta legittima, Dogecoin, che si posiziona al nono posto per capitalizzazione di mercato, con una capitalizzazione di mercato di 10 miliardi di dollari.</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 ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p></div></div></div>