Q2hyaXN0aWFubyBSb25hbGRvIGFmZnJvbnRhIHNmaWRlIGxlZ2FsaSBwZXIgbGEgcHJvbW96aW9uZSBkaSBCaW5hbmNl

2023-12-13, 05:46

<p><img src="https://gimg2.gateimg.com/image/article/1700024128RDZZ 1.jpeg" alt=""><br>Diversi investitori di NFT stanno citando in giudizio Christiano Ronaldo per la promozione delle NFT di Binance.</p>
<p>Il valore degli NFT di Ronaldo è crollato da tra $77 e $10.000 a circa $1 in un anno.</p>
<p>Tom Brady, Gisele Bundchen, Kardashian e Floyd Mayweather Jr sono altri celebrità delle criptovalute che sono stati citati in giudizio per la promozione di asset digitali come le criptovalute.</p>
<p>Parole chiave: celebrità cripto, causa di Binance, CEO di Binance, Binance Exchange, problemi di Binance, sponsorizzazione di Binance NFT, promozione di Binance NFT, SEC vs. Binance, collezione di NFT di Ronaldo, prezzo di NFT di Ronaldo</p>
<h2 id="h2-Introduzione995192"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Molte aziende in tutto il mondo utilizzano celebrità per promuovere le loro attività e i loro marchi per attrarre molti clienti. Anche se questa pratica funziona bene nel settore commerciale convenzionale, ha creato sfide nel settore delle criptovalute.</p>
<p>Già, clienti e autorità di regolamentazione hanno citato in giudizio diverse celebrità come Christiano Ronaldo, Tom Brady, Gisele Bundchen, Kardashian e Floyd Mayweather, Jr per la promozione di attività cripto.</p>
<p>Oggi ci concentriamo su una recente causa collettiva contro Christiano Ronaldo per la promozione dello scambio di criptovalute Binance e dei suoi prodotti. Discuteremo anche altre cause legali per celebrità di spicco come Tom Brady e Gisele Bundchen.</p>
<h2 id="h2-Christiano20Ronaldo20affronta20una20causa20collettiva20per20aver20promosso20Binance424419"><a name="Christiano Ronaldo affronta una causa collettiva per aver promosso Binance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Christiano Ronaldo affronta una causa collettiva per aver promosso Binance</h2><p>Christiano Ronaldo, la stella del calcio portoghese, sta affrontando una causa collettiva da 1 miliardo di dollari per aver promosso Binance, la più grande cripto borsa al mondo, e i suoi prodotti. Il vero caso legale è che Ronaldo ha promosso titoli non registrati offerti al pubblico da Binance.</p>
<p>Notizie correlate: <a href="https://www.gate.io/blog_detail/3196/ronaldinho-pyramid-scheme" target="_blank">Ronaldinho smentisce legami con presunto schema piramidale di criptovalute</a></p>
<h2 id="h2-La20class20action20contro20Ronaldo474716"><a name="La class action contro Ronaldo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La class action contro Ronaldo</h2><p>La class-action di Ronaldo deriva dalla sua associazione con Binance, dove ha promosso i suoi token non fungibili ( <a href="https://www.gate.io/learn/articles/what-are-nfts/4" target="_blank">NFT</a>). La causa, presentata in un tribunale distrettuale degli Stati Uniti in Florida, afferma che Ronaldo ha attivamente pubblicizzato titoli che Binance offre ma che, tuttavia, non sono registrati.</p>
<p>Il <a href="https://dockets.justia.com/docket/florida/flsdce/1:2023cv24481/658307" rel="nofollow noopener noreferrer" target="_blank">cause legale</a> sostiene che la partecipazione di Ronaldo abbia attirato molti investitori ad acquistare Binance NFT che sono strumenti di sicurezza non registrati. In sostanza, la stella del calcio ha collaborato con Binance nel novembre 2022 per promuovere i suoi prodotti digitali, in particolare gli NFT. Un esempio specifico di titoli non registrati è una collezione di NFT che hanno le iniziali e il numero di maglia di Ronaldo, conosciuti popolarmente come NFT di Ronaldo.</p>
<p>Il <a href="https://www.binance.com/en/blog/nft/cristiano-ronaldo-the-nft-collection-5556607489226167192 &quot;CR7 (Ronaldo NFTs" rel="nofollow noopener noreferrer" target="_blank">CR7 (Ronaldo NFTs) comprende una serie di prodotti</a> comprende una gamma di prodotti che includono calzature e fragranze, mirati a elevare il calcio nel mondo digitale. Ha 7 statue animate che mostrano i momenti iconici di Ronaldo nella sua carriera calcistica, tra cui i suoi gol in rovesciata e la sua leggendaria finta.</p>
<p>Ogni tipo aveva 777.777 NFT. Inoltre c’era un’offerta speciale per i nuovi utenti di Binance che hanno aperto i loro account utilizzando il codice di Ronaldo. Ciascuno di questi investitori aveva diritto a una “CR7 Mystery Box” con un NFT speciale.</p>
<p>Al momento del lancio, i prezzi degli NFT variavano tra $77 e 10.000 ciascuno. Tuttavia, i loro valori sono crollati a circa $1 ciascuno dopo un periodo di un anno, causando notevoli perdite per gli investitori. Gli attori accusano Ronaldo di aver rilasciato dichiarazioni ingannevoli durante la promozione di questi asset digitali.</p>
<p>Inoltre, i querelanti sostengono che Ronaldo non abbia rivelato il compenso che Binance gli ha dato come previsto dalla legge. Inoltre, la causa sottolinea che attraverso gli annunci, Binance e Ronaldo hanno mirato a investitori che non erano ben versati in tali asset di investimento.</p>
<p>Le accuse contro Ronaldo sono simili a quelle mosse contro <a href="https://www.sec.gov/news/press-release/2023-34" rel="nofollow noopener noreferrer" target="_blank">Paul Pierce. Nel caso di Paul Pierce, un giocatore NBA vs SEC</a>, Gary Gensler, il presidente dell’autorità di regolamentazione, ha sottolineato che fare dichiarazioni fuorvianti su un titolo può comportare una causa civile. Ha anche dichiarato che qualsiasi <a href="https://www.gate.io/blog_detail/529/celebrities-that-have-entered-the-nft-world-like-owning-bayc" target="_blank">celebrità che promuove una sicurezza come gli NFT</a> dovrebbe rendere pubblica la compensazione che ottiene per farlo.</p>
<p>Gensler ha detto: “Questo caso è un altro promemoria per le celebrità: la legge richiede di divulgare al pubblico da chi e quanto si viene pagati per promuovere gli investimenti in titoli, e non si può mentire agli investitori quando si pubblicizza un titolo.”</p>
<p>Nello stesso comunicato stampa, <a href="https://www.sec.gov/news/press-release/2023-34" rel="nofollow noopener noreferrer" target="_blank">Gurbir S. Grewal, il Direttore della Divisione dell’Applicazione della Legge della SEC, ha detto</a>«Le leggi federali sui titoli valori sono chiare nel senso che ogni celebrità o altra persona che promuove un titolo valutario criptato deve divulgare la natura, la fonte e l’importo della compensazione ricevuta in cambio della promozione.»</p>
<p>Ha aggiunto che gli investitori hanno il diritto di sapere se un promotore di un titolo è imparziale.</p>
<p>Infine, <a href="https://www.sec.gov/news/press-release/2023-34" rel="nofollow noopener noreferrer" target="_blank">Gensler ha consigliato anche</a> essere vigili quando si investe in asset digitali che alcuni celebrità sponsorizzano. <a href="https://www.sec.gov/news/press-release/2023-34" rel="nofollow noopener noreferrer" target="_blank">Ha detto</a>, “Quando le celebrità avallano opportunità di investimento, compresi i titoli di criptoattivi, gli investitori dovrebbero fare attenzione a valutare se gli investimenti sono adatti a loro e dovrebbero sapere perché le celebrità stanno facendo quelle avallate.”</p>
<p>Sulla base delle linee guida sopra citate, dalla SEC, i querelanti che includono Michael Sizemore, Mikey Vongdara e Gordon Lewis, stanno cercando un risarcimento per le perdite subite e per le spese legali.</p>
<p>Ad esempio, Ronaldo ha pubblicizzato gli NFT sul suo profilo X che conta oltre 110 milioni di follower. È anche importante notare che Ronaldo ha promosso Binance Coin ( <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>). Secondo Coinpaprika, la causa ha portato a un aumento del 500% nelle ricerche di Binance, che potrebbe aver contribuito a un volume di vendite molto elevato.</p>
<p>Pubblicazione su X, <a href="https://twitter.com/coinpaprika/status/1729760458939216347" rel="nofollow noopener noreferrer" target="_blank">Coinpaprika ha detto</a>, “Causa intentata contro Cristiano Ronaldo per aver promosso i titoli non registrati di Binance, che ha scatenato un aumento del 500% delle ricerche di #Binance”.</p>
<p>Leggi anche: <a href="https://www.gate.io/learn/articles/what-are-the-main-nft-collections/934" target="_blank">Quali sono le principali collezioni NFT?</a></p>
<h2 id="h2-Gli20NFT20sono20titoli255499"><a name="Gli NFT sono titoli?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gli NFT sono titoli?</h2><p>Abbiamo discusso della class action contro Ronaldo che ha promosso i titoli Binance sotto forma di NFT. Questo solleva la questione se gli NFT siano o meno titoli. In effetti, la Securities and Exchange Commission (SEC) degli Stati Uniti classifica <a href="https://www.gate.io/blog_detail/2708/sec-labels-37-cryptocurrencies-as-securities-implications-for-trading" target="_blank">token non fungibili come titoli</a>. Pertanto, le celebrità che le pubblicizzano dovrebbero attenersi ai requisiti di divulgazione del paese.</p>
<h2 id="h2-Potenziali20conseguenze20su20Binance20e20Ronaldo99350"><a name="Potenziali conseguenze su Binance e Ronaldo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potenziali conseguenze su Binance e Ronaldo</h2><p>La class action potrebbe influenzare in un modo o nell’altro sia Ronaldo che Binance. Se trovato colpevole, a Ronaldo potrebbe essere richiesto di pagare $1 miliardo in danni ai querelanti. Il tribunale potrebbe anche richiedergli di pagare i costi legali associati.</p>
<p>Naturalmente, la reputazione di Ronaldo potrebbe essere danneggiata al punto che altre aziende potrebbero evitare di utilizzarlo come loro ambasciatore o promotore.</p>
<p>È improbabile che Binance possa incorrere in costi derivanti da questa causa legale. Per ora, sembra che la maggior parte dei problemi di Binance legati a titoli e altre questioni siano stati risolti attraverso l’accordo di 4 miliardi di dollari che ha avuto con varie autorità regolatorie degli Stati Uniti.</p>
<p>L’accordo è seguito alla condanna di Binance Exchange e Changpeng Zhao, ex CEO di Binance, per violazione delle leggi anti-riciclaggio e altre accuse.</p>
<p>Fondamentalmente, i 4 miliardi di dollari sono un accordo per le molteplici accuse penali di Binance, il che significa che è improbabile che l’exchange debba affrontare altri problemi legali derivanti dal passato. Tuttavia, è probabile che la sfilza di cause legali contro Binance intacchi la reputazione dell’exchange.</p>
<h2 id="h2-Potenziali20effetti20della20classaction20di20Ronaldo20sulla20posizione20di20mercato20di20Binance674689"><a name="Potenziali effetti della class-action di Ronaldo sulla posizione di mercato di Binance" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Potenziali effetti della class-action di Ronaldo sulla posizione di mercato di Binance</h2><p>Non c’è dubbio che la causa collettiva di Ronaldo possa danneggiare ulteriormente la reputazione di Binance, il che influisce sulla sua posizione di mercato. Già da inizio anno la quota di mercato di Binance è diminuita a causa di varie controversie legali con le agenzie di regolamentazione degli Stati Uniti come la SEC.</p>
<p>La quota di mercato di Binance è diminuita significativamente rispetto alla sua posizione di febbraio 2023. Alcuni mesi dopo il crollo di FTX, il volume di trading di Binance rappresentava circa il 66% dell’intero mercato. Ad esempio, nel marzo 2023, la piattaforma ha registrato un alto volume di trading di <a href="https://www.coingecko.com/research/publications/centralized-crypto-exchanges-market-share" rel="nofollow noopener noreferrer" target="_blank">$559.8 miliardi</a> Tuttavia, alla fine di settembre il volume degli scambi era diminuito a $132.5 miliardi.</p>
<p>Allo stesso modo, il suo trading <a href="https://www.coingecko.com/research/publications/centralized-crypto-exchanges-market-share" rel="nofollow noopener noreferrer" target="_blank">il volume è diminuito di circa il 30,3%</a> tra agosto e settembre. La causa principale del declino sono le sfide regolatorie che ha affrontato durante l’anno. Pertanto, eventuali ulteriori contenziosi contro Binance potrebbero ulteriormente minacciare la sua quota di mercato.</p>
<h2 id="h2-Altri20celebrit20delle20criptovalute20che20hanno20affrontato20cause20legali906517"><a name="Altri celebrità delle criptovalute che hanno affrontato cause legali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Altri celebrità delle criptovalute che hanno affrontato cause legali</h2><p>Ronaldo non è stato il primo personaggio famoso ad affrontare cause legali per la promozione di aziende di criptovalute. Celebrità delle criptovalute come Tom Brady, Gisele Bundchen, Kardashian e Floyd Mayweather Jr sono state citate in giudizio per la promozione di asset digitali come criptovalute e NFT.</p>
<p>Più specificamente, nel 2022 dopo il crollo di FTX, diverse celebrità hanno affrontato cause collettive per aver promosso lo scambio. Ad esempio, un investitore ha citato in giudizio Larry David, Gisele Bundchen e Tom Brady per aver promosso e sponsorizzato lo scambio FTX. Una delle principali accuse era che queste celebrità non avevano adeguatamente rivelato le loro relazioni con lo scambio. Tuttavia, le celebrità hanno chiesto il rigetto del caso.</p>
<p>Le altre celebrità cripto che hanno affrontato un’altra causa legale sono Kardashian e Floyd Mayweather, Jr. In quel caso, l’accusa principale era che i promoter celebrità abbiano collaborato con i dirigenti della criptovaluta EthereumMax per attirare gli investitori ad acquistare il token EMax, il che ha fatto salire il suo prezzo.</p>
<p>Alla fine, i dirigenti di EthereumMax hanno venduto la criptovaluta a valori elevati. La SEC ha addebitato a Kardashian una multa di 1,26 milioni di dollari che ha accettato di pagare.</p>
<p>Tuttavia, un giudice federale ha respinto il caso contro Floyd Mayweather, Jr. sulla base del fatto che non c’era prova che gli investitori che hanno acquistato il token EMax abbiano visto le promozioni. Riguardo alla promozione di asset digitali, Charles Whitehead, professore alla Cornell Law School, ha detto che i promotori dovrebbero essere cauti.</p>
<p><a href="https://edition.cnn.com/2022/12/14/tech/celebrity-crypto-lawsuits/index.html" rel="nofollow noopener noreferrer" target="_blank">In un’intervista con CNN, Whitehead ha detto</a>“Vendere un asset che è uno strumento finanziario … non è la stessa cosa che vendere scarpe da ginnastica.”</p>
<p>Ha aggiunto: ‘Tutte queste celebrità che corrono in giro e fanno queste sponsorizzazioni dovrebbero fermarsi e chiedere consiglio a un avvocato specializzato in titoli’.</p>
<p>Alla fine, queste cause legali hanno mostrato le sfide regolatorie che i personaggi famosi delle criptovalute affrontano quando promuovono asset digitali, soprattutto titoli.</p>
<h2 id="h2-Conclusion347804"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Christiano Ronaldo sta affrontando una causa collettiva da 1 miliardo di dollari negli Stati Uniti per la promozione e l’approvazione dei prodotti Binance come NFT, che la SEC ritiene essere titoli. La SEC sostiene che Binance non li abbia registrati. D’altro canto, i querelanti stanno citando in giudizio Ronaldo per i danni delle perdite subite per aver investito nella collezione di NFT di Ronaldo.</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 patto 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>