QWFuZ2VwYXN0ZSBjbGFzcy1hY3Rpb24gcmVjaHRzemFhayBiZXdlZXJ0IGRhdCBFbG9uIE11c2sgSW5zaWRlciBUcmFkaW5nIHBsZWVndCBpbiBEb2dlY29pbg==

2023-06-14, 03:39

<p><img src="https://gimg2.gateimg.com/image/article/1684401663RDZZ.jpeg" alt=""><br>De eiser in de zaak van Musks handel met voorkennis heeft verzocht om verlof om een collectieve actie te wijzigen met de bedoeling nieuwe beschuldigingen toe te voegen.</p>
<p>De Dogecoin-investeerders die Musk aanklagen, beweren dat hij de prijs van de cryptocurrency heeft gemanipuleerd om te profiteren van de kortetermijnprijsveranderingen.</p>
<p>Musk en zijn juridisch team hebben geen commentaar gegeven op het verzoek van de Dogecoin-investeerders om een ​​class-action te wijzigen.</p>
<p>Zoekwoorden: Twitter CEO, Elon Musk, crypto rechtszaak, Doge crypto, Dogecoin, Doge handel, Twitter logboek gewijzigd, <a href="/price/dogecoin-doge" target="_blank" class="blog_inner_link">Dogecoin</a> investeerders</p>
<h2 id="h2-Introductie975817"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Tijdens de beginjaren van cryptocurrencies waren er nauwelijks juridische stappen tegen individuen en cryptoinstituten zoals beurzen. Momenteel nemen echter individuen en overheidsinstanties in de Verenigde Staten en enkele andere landen actie tegen potentiële overtreders. In dit artikel bespreken we een rechtszaak tegen Elon Musk.</p>
<h2 id="h2-Gewijzigde20class20action20tegen20Elon20Musk289529"><a name="Gewijzigde class action tegen Elon Musk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gewijzigde class action tegen Elon Musk</h2><p>Een groep Dogecoin investeerders die Elon Musk, de voormalige CEO van Twitter, hebben aangeklaagd, hebben gevraagd om toestemming om een class-action rechtszaak tegen hem te wijzigen op de beschuldiging dat hij de markt heeft gemanipuleerd. <a href="https://www.gate.io/price/dogecoin-doge" target="_blank">prijs van Dogecoin</a> voor zijn persoonlijk voordeel en dat van zijn bedrijf Tesla Inc.</p>
<p>Aanvankelijk dienden de investeerders in juni 2022 een juridische zaak in tegen Musk na zijn beruchte optreden in Saturday Night Live, dat hij bijwoonde voordat hij Twitter overnam. Desalniettemin had hij al laten zien <a href="https://www.gate.io/blog_detail/2507/dogecoin-mask-returns-twitter-logo" target="_blank">veel interesse in het bevorderen van Dogecoin</a> Eén van de toonaangevende memecoins, op sociale platforms vooral Twitter. Tot nu toe hebben de eisers de rechtszaak twee keer gewijzigd als gevolg van de acties van Musk en opkomende details.<br><img src="https://gimg2.gateimg.com/image/article/16867137941.png" alt=""><br>Elon Musk- NYtimes</p>
<p>Op 31 mei van dit jaar diende de genoemde groep investeerders hun zaak in tegen Musk bij de United States District Court voor het Southern District of New York, waar ze beweerden dat Musk zijn grote aanhang op Twitter en andere openbare media gebruikte om winst te maken uit de handel in Dogecoin via wat zij cryptocurrency-marktmanipulatie noemden.</p>
<p>Lees ook: <a href="https://www.gate.io/price-prediction/dogecoin-doge" target="_blank">Dogecoin (DOGE) Prijsvoorspelling 2023-2030</a></p>
<p>Ze verklaarden dat als het niet was voor de ‘materiële onjuistheden en weglatingen van Musk, eisers en de klasse Dogecoin niet zouden hebben gekocht.’<br><strong>Ze suggereerden dat Tesla en Musk ‘onrechtmatig verrijkt waren met miljarden dollars’ als gevolg van ‘niet-gemelde verkopen van <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> gebaseerd op interne informatie.</strong>”</p>
<p>Bovendien zei de eiser dat Musk ‘uitgebreide verantwoordelijkheid nam voor het Dogecoin-bedrijf als geheel, waardoor de fiduciaire relatie ontstond die nodig was om een claim voor insider trading in te dienen’.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2236/doge-floki-soar-musk-tweets-photo-dog-twitter-ceo-chair" target="_blank">Doge en Floki stijgen nadat Musk een foto van zijn hond op de CEO-stoel van Twitter heeft getweet</a></p>
<p>Ook beweerden ze dat Musk onjuiste informatie gaf toen hij zei dat zijn bedrijf, SpaceX, de prijs van Dogecoin naar de maan zou sturen, iets wat niet is gebeurd.</p>
<p>Volgende, de investeerders <a href="https://edition.cnn.com/2023/04/27/tech/elon-musk-twitter-six-months/index.html" rel="nofollow noopener noreferrer" target="_blank">beweerde dat Elon Musk</a> begon Twitter te gebruiken om de prijzen van verschillende cryptocurrencies te beïnvloeden, waaronder <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en Dogecoin in 2019. Afgezien van de bewering dat Musk betrokken was bij handel met voorkennis van Doge crypto, beweren ze ook dat Doge een effect is, gebaseerd op de Howey-test.</p>
<p>Als gevolg daarvan verklaarde de gewijzigde rechtszaak: “Dit is een class action-rechtszaak wegens effectenfraude die voortkomt uit een opzettelijke koers van kermisbarkettenmarktmanipulatie en handel met voorkennis door ‘s werelds rijkste man Elon Musk, die een opkomend popcultuurverschijnsel kaapte om zichzelf en zijn bedrijven te promoten, en zijn obscene fortuin aan te vullen, inspelend op de oprechte hoop van kwetsbare Amerikanen, waaronder oorlogsveteranen, arbeiders en ouderen.”</p>
<p>Desalniettemin heeft de SEC niet bevestigd dat Dogecoin een cryptobeveiliging is. Als zodanig behoort het niet tot de 68 cryptocurrencies die de SEC heeft vermeld als cryptocurrency-effecten.</p>
<p>Op het moment van schrijven heeft Musk, een van ‘s werelds rijkste mensen, nog niet gereageerd op de laatste beschuldigingen. De andere klacht is echter dat Twitter zijn iconische blauwe vogellogo heeft vervangen door de afbeelding van <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a> hond, wat Dogecoin vertegenwoordigt, wat leidde tot een stijging van 30% in de waarde van de cryptocurrency.</p>
<p>Op een vergelijkbare manier hebben Dogecoin-investeerders ook beweerd dat Musk de prijs van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> heeft gemanipuleerd via zijn sociale media-activiteiten op een moment dat zijn bedrijf, Tesla, het verhandelde. Niettemin hebben ze in hun recente wijziging alleen Musk en Tesla als de beklaagden vermeld, omdat ze de Dogecoin Foundation hebben laten vallen.</p>
<p>De eiser betoogde dat “Musk winstgevend Dogecoin verhandelde via één of meer portefeuilles en binnenlandse beurzen met voorafgaande kennis die toen nog onbekend en niet bekend was bij Dogecoin-investeerders in het algemeen of openbaar, van zijn eigen bedoelde bewegingen om de markt te manipuleren.”</p>
<p>Bijgevolg hebben de verweerders het recht om te reageren op de gewijzigde klachten voor 14 juni 2023. Zoals het er nu voor staat, is de rechtbank waarschijnlijk bereid om toestemming te verlenen voor een gewijzigde collectieve vordering. Dit komt omdat rechter Alvin Hellerstein in een afzonderlijk document heeft verklaard dat ‘het verzoek van de eisers om die klacht in te dienen waarschijnlijk zal worden toegewezen, aangezien er waarschijnlijk geen nadeel zal zijn voor de verweerders van Tesla, en toestemming om een gewijzigde klacht in te dienen vrijelijk wordt verleend.’<br>Musk’s juridische team reageert</p>
<p>Intussen heeft het juridische team van Musk weerlegd dat Elon Musk enige frauduleuze activiteit heeft gepleegd of insider trading heeft uitgevoerd. De advocaten hebben beweerd dat hun cliënt geen enkele wet heeft overtreden door wat memes en foto’s te plaatsen.</p>
<p>Volgens hen waren het ‘gewoon grappige foto’s over een legitieme cryptocurrency’. Ze voegden eraan toe: ‘Het is een legitieme cryptocurrency - inderdaad een van de grootste - die bijna $10 miljard waard is.’ Hun argument hier is dat Dogecoin geen ponzi-cryptoschema is, zoals de eiser beweert.</p>
<p>Bovendien vroegen ze op 3 mei de rechtbank om het tweede gewijzigde verzoekschrift tegen Musk af te wijzen. Ze hebben echter nog geen standpunt ingenomen over het recentste verzoek om het groepsgeding te wijzigen.</p>
<h2 id="h2-Prestaties20van20Dogecoin20te20midden20van20de20voortdurende20rechtszaak545745"><a name="Prestaties van Dogecoin te midden van de voortdurende rechtszaak" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Prestaties van Dogecoin te midden van de voortdurende rechtszaak</h2><p>In feite is de prijs van Dogecoin gedurende het grootste deel van 2023 vlak geweest, een periode waarin de zaak tussen Musk en Dogecoin-investeerders zich voortsleept. De waarde ervan schommelt tussen $0,07 en $0,09, zoals aangegeven op de volgende diagram.<br><img src="https://gimg2.gateimg.com/image/article/16867138932.png" alt=""><br>Dogecoin Prijsprestaties in 2023 - Statista</p>
<p>Zoals je op de bovenstaande grafiek ziet, <a href="https://www.gate.io/trade/DOGE_USDT" target="_blank">Doge handelde onder $0.09</a> voor het grootste deel van 2023. Op het moment van schrijven handelt het voor $0.621, ongeveer 91,51% minder dan zijn all-time-high van $0.731 behaald op 8 mei 2021.</p>
<h2 id="h2-Conclusie415406"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Sommige investeerders in Dogecoin gaan door met hun crypto-rechtszaak tegen Musk omdat hij naar verluidt de prijs van Doge heeft gemanipuleerd via zijn activiteiten op Twitter en andere openbare mediakanalen. Musk en zijn juridische team beweren echter dat hij niets illegaals heeft gedaan omdat hij een paar foto’s en opmerkingen heeft geplaatst over een legitieme cryptocurrency, Dogecoin, gerangschikt op nummer 9 op basis van marktkapitalisatie, met een marktkapitalisatie van $ 10 miljard.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Gate.io-onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>