Um9uYWxkaW5obyBuZWdhIGxlZ2FtaSBjb24gcHJlc3VudG8gc2NoZW1hIHBpcmFtaWRhbGUgY3JpcHRv

2023-09-13, 10:29

<p><img src="https://gimg2.gateimg.com/image/article/1694600463RDZZ 1.jpeg" alt=""></p>
<h2 id="h2-In20breve20troppo20lungo20da20leggere20TL20DR851199"><a name="In breve; troppo lungo da leggere (TL: DR)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>In breve; troppo lungo da leggere (TL: DR)</h2><p>Ronaldinho ha smentito le accuse secondo cui fosse coinvolto in uno schema crypto fraudolento chiamato 18kRonaldinho.</p>
<p>Le autorità brasiliane potrebbero detenere Ronaldo de Assis Moreira per non aver partecipato alle altre udienze in tribunale.</p>
<p>Kylian Mbappe, Cristiano Ronaldo, Luis Suarez, Lionel Messi, Roberto Carlos e Antoine Griezmann sono esempi di stelle del calcio che sono coinvolti nelle criptovalute.</p>
<h2 id="h2-Introduzione179833"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Molti personaggi dello sport, tra cui atleti e giocatori di calcio, sono coinvolti in criptovalute e altri asset digitali. Ad esempio, giocatori di calcio famosi come Kylian Mbappe, <a href="https://www.gate.io/nft/42574" target="_blank">Cristiano Ronaldo</a>, Luis Suarez, Lionel Messi, Roberto Carlos e Antoine Griezmann partecipano alle attività di criptovaluta.</p>
<p>Oggi parleremo di come alcune di queste stelle del calcio stanno partecipando alle attività criptate. Esamineremo anche le accuse contro il coinvolgimento di Ronaldinho in <a href="https://www.gate.io/bitwiki/detail/205/pyramid-scheme" target="_blank">uno schema piramidale criptato</a>.</p>
<p>Dai un’occhiata <a href="https://www.gate.io/nft/collection/10886/Fantasy-Football" target="_blank">Fantasy Football NFTs</a></p>
<h2 id="h2-Ronaldinho20smentisce20il20coinvolgimento20in20uno20schema20di20piramide20cripto695163"><a name="Ronaldinho smentisce il coinvolgimento in uno schema di piramide cripto" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ronaldinho smentisce il coinvolgimento in uno schema di piramide cripto</h2><p>La popolare stella del calcio Ronaldo de Assis Moreira, conosciuto principalmente come Ronaldinho Gaucho, ha negato di essere coinvolto in uno schema piramidale crypto che ha truffato gli investitori di oltre 61 milioni di dollari. Il 31 agosto, il calciatore ritirato Ronaldinho Gaúcho ha presentato la sua versione dei fatti in un’audizione congressuale in Brasile.</p>
<p>Ronaldinho ha smentito qualsiasi coinvolgimento nello schema chiamato “18kRonaldinho” che prometteva agli investitori un rendimento giornaliero del 2% sui loro asset crittografici investiti.</p>
<p>Le autorità brasiliane hanno affermato: “L’azienda ha dichiarato di lavorare con il trading e l’arbitraggio di criptovalute e ha promesso ai propri clienti un reddito fino al 2% al giorno, presumibilmente basato su operazioni con valute digitali, suscitando sospetti che si trattasse di una piramide finanziaria a causa delle promesse di alti e rapidi rendimenti.”</p>
<p>La causa intentata contro di lui chiede 61 milioni di dollari di danni. Tuttavia, in sua difesa, Ronaldinho ha detto di essere anch’egli una vittima della truffa poiché sono state utilizzate le sue immagini e il suo nome senza la sua autorizzazione.</p>
<p>Durante l’udienza il panel ha mostrato a Ronaldinho le sue foto utilizzate come parte del materiale di marketing del sistema piramidale. Tuttavia, Ronaldinho ha mantenuto che le immagini sono state scattate nel 2019 quando ha collaborato con una delle sussidiarie dell’azienda, una società di orologi statunitense chiamata 18k Watch Corporation, che vende orologi.</p>
<p>Ha detto: “Hanno abusato del mio nome per creare il nome aziendale di questa società”. Tuttavia, secondo una fonte, ha rifiutato di rispondere ad alcune domande poste dal panel. Ad esempio, quando Aureo Ribeiro, il presidente dell’inchiesta, gli ha chiesto se fosse disposto o meno a rimborsare le vittime della truffa criptovalutaria, è rimasto in silenzio.</p>
<p>Secondo Ronaldinho, la 18k Watch Corporation ha lanciato una serie di orologi che portavano immagini di alcuni popolari calciatori, incluso lui stesso. Tuttavia, ha sottolineato che l’azienda ha terminato il suo contratto prima della sua attuazione.</p>
<p>Leggi anche: <a href="https://www.gate.io/price/view/sports" target="_blank">Le migliori monete e token criptovalutari per lo sport per capitalizzazione di mercato</a></p>
<h2 id="h2-Lawsuit20Demands206120Million20from20Ronaldinho176130"><a name="Lawsuit Demands $61 Million from Ronaldinho" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lawsuit Demands $61 Million from Ronaldinho</h2><p>Come accennato in precedenza, la causa legale contro Ronaldinho richiede un totale di 300 milioni di reais, equivalenti a circa 60,66 milioni di dollari come compensazione. Secondo Reuters, l’Istituto per le Relazioni con i Consumatori del Brasile ha presentato la causa collettiva nel 2020.</p>
<h2 id="h2-Ronaldinho20preoccupato20per20lazione20della20polizia20dopo20aver20mancato20le20comparizioni20in20tribunale825817"><a name="Ronaldinho preoccupato per l’azione della polizia dopo aver mancato le comparizioni in tribunale" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ronaldinho preoccupato per l’azione della polizia dopo aver mancato le comparizioni in tribunale</h2><p>Attualmente, Ronaldinho teme ritorsioni della polizia dopo aver mancato due udienze nel mese di agosto. Ad esempio, ha saltato l’ultima udienza il 24 agosto citando le pessime condizioni meteorologiche. Ha sostenuto che il cattivo tempo ha causato la cancellazione dei voli che voleva prendere.</p>
<p>A seguito del suo fallimento a comparire alle udienze giudiziarie indicate, le autorità brasiliane potrebbero detenerlo per un periodo di tempo e in termini non ancora noti. Se le autorità sono indulgenti, potrebbero infliggergli una multa per non aver partecipato alle udienze giudiziarie.</p>
<p>Fondamentalmente, il Congresso sta attualmente indagando su un totale di 11 casi di frode correlati alle criptovalute in cui i perpetratori hanno promesso enormi guadagni alle vittime.</p>
<h2 id="h2-1020migliori20giocatori20attivi20nella20criptovaluta137070"><a name="10 migliori giocatori attivi nella criptovaluta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>10 migliori giocatori attivi nella criptovaluta</h2><p>Oltre a Ronaldo de Assis Moreira, ci sono diversi calciatori passati e presenti nel settore delle criptovalute. Kylian Mbappe, Cristiano Ronaldo, Luis Suarez, Lionel Messi, Roberto Carlos e Antoine Griezmann sono esempi di altri calciatori coinvolti nelle criptovalute.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/529/celebrities-that-have-entered-the-nft-world-like-owning-bayc" target="_blank">Celebrità che sono entrate nel mondo NFT</a></p>
<h2 id="h2-Lionel20Messi230829"><a name="Lionel Messi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lionel Messi</h2><p>Lionel Messi, uno dei più grandi calciatori di tutti i tempi, è un esempio di individuo che si interessa di criptovalute e calcio. Quando è stato trasferito dal Barcellona al Paris St. Germain, l’accordo includeva un pagamento parziale in criptovaluta.</p>
<p>Inoltre, nel 2022 Messi ha stipulato un accordo con Socios.com, un’azienda di token per fan digitali, per promuovere il suo marchio. L’accordo del valore di oltre 20 milioni di dollari ha permesso a Messi di partecipare alla campagna promozionale di Socios in vista della Coppa del Mondo del Qatar. Tuttavia, prima di ciò, nel 2018 Messi è stato nominato ambasciatore di Sirin Labs, un produttore di smartphone alimentato da blockchain.</p>
<h2 id="h2-Kylian20Mbappe278278"><a name="Kylian Mbappe" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Kylian Mbappe</h2><p>Kylian Mbappé, un sensazionale calciatore, è un altro esempio di una persona attiva sia nel campo delle criptovalute che nello sport. Mbappé è stato introdotto per la prima volta alle criptovalute quando ha segnato il suo gol di debutto per il Paris Saint-Germain (PSG) il 10 marzo.</p>
<p>Dopo quel gol, Kinetic Capital e Gravitas Limited, una società di criptovalute, hanno donato la propria nativa <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> token basato su Kineticcoachcoin (KKC), a Mbappe. Da lì ha iniziato ad usare le criptovalute.</p>
<h2 id="h2-Neymar20Jr660132"><a name="Neymar Jr." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Neymar Jr.</h2><p>Una delle stelle nel campo delle criptovalute è Neymar Jr., il calciatore brasiliano <a href="/price/icon-icx" rel="nofollow noopener noreferrer" target="_blank">ICON</a>, che finora ha collaborato con diversi progetti digitali che utilizzano “i giocatori promuovono campagne crypto”. Di conseguenza, ha promosso progetti crypto attraverso video e post sui social media.</p>
<p>Investe anche in criptovalute. Ad esempio, è ben noto per aver investito in Bitstamp, una piattaforma di scambio rinomata. Inoltre, mette i suoi fondi in altri asset digitali, in particolare token non fungibili. Ad esempio, nel 2022 ha speso oltre 1 milione di dollari per 2 NFT che fanno parte del <a href="div class=" rel="nofollow noopener noreferrer" target="_blank" title="blog-details-info\&quot;> <div>Author:** Mashell C.**, Gate.io Researcher <div class=\&quot;info-tips\&quot;>\*This article represents only the views of the researcher and does not constitute any investment suggestions. <div>\*Gate.io reserves all rights to this article. Reposting of the article will be permitted provided Gate.io is referenced. In all cases, legal action will be taken due to copyright infringement. </div> \&quot;Bored Ape Yacht Club">Bored Ape Yacht Club</a> progetto (BAYC).</p>
<h2 id="h2-Cristiano20Ronaldo475407"><a name="Cristiano Ronaldo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cristiano Ronaldo</h2><p>La prossima stella del calcio attiva nel campo delle criptovalute è Christiano Ronaldo. Curiosamente, l’attaccante portoghese guadagna circa 35 milioni di dollari attraverso redditizi accordi di sponsorizzazione sportiva.</p>
<p>Ad esempio, Stryking, una società di criptovalute in arrivo, ha nominato Ronaldo come uno dei suoi portavoce. Stryking vuole che Ronaldo attiri molti appassionati di sport a utilizzare i suoi prodotti. Fondamentalmente, la piattaforma offre ai suoi clienti l’opportunità di acquistare beni virtuali speciali, tra cui biglietti per le partite e maglie autografate.</p>
<p>Inoltre, Ronaldo ha recentemente investito molti fondi in MC10, una promettente azienda di criptovalute. Inoltre, utilizza le sue piattaforme di social media per promuovere i prodotti di MC10. E in cambio, guadagna azioni in MC10, aumentando così il suo coinvolgimento nell’industria delle criptovalute.</p>
<h2 id="h2-Luis20Suarez529507"><a name="Luis Suarez" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Luis Suarez</h2><p>Da molto tempo, Luis Suarez, una delle stelle del calcio più apprezzate nel mondo delle criptovalute, collabora con varie startup di criptovalute che includono Stox, un protocollo di mercato delle previsioni basato su Ethereum.</p>
<p>Ad esempio, coinvolge i suoi oltre 30 milioni di follower su Instagram per partecipare ad attività crittografiche come fare previsioni su Stox. Di conseguenza, un certo numero di suoi fan sui social media sono coinvolti in diversi progetti di start-up crypto.</p>
<h2 id="h2-Ronaldinho332173"><a name="Ronaldinho" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ronaldinho</h2><p>Come abbiamo notato in precedenza, Ronaldinho è coinvolto in diversi progetti criptovalutari e piattaforme di investimento. È un calciatore di grande reputazione che ha lanciato il suo progetto di criptovaluta chiamato Ronaldinho Soccer Coin (RSC) Project. Il suo obiettivo è rendere RSC una valuta globale per le attività sportive. Alcuni dei prodotti e servizi sulla piattaforma sono le scommesse sportive e gli stadi digitali.</p>
<h2 id="h2-Roberto20Carlos215053"><a name="Roberto Carlos" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Roberto Carlos</h2><p>Roberto Carlos, uno dei rinomati terzini brasiliani, ha recentemente lanciato la sua criptovaluta chiamata RC3, disponibile sulla piattaforma Rally.</p>
<h2 id="h2-Antoine20Griezmann929568"><a name="Antoine Griezmann" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Antoine Griezmann</h2><p>Antoine Griezmann, un altro importante calciatore francese, ha anche abbracciato la criptovaluta e la tecnologia blockchain. Ad esempio, utilizza le sue piattaforme di social media per promuovere vari progetti cripto. Di conseguenza, ha stretto partnership con diverse aziende cripto. Inoltre, è noto per sostenere l’Atletico Madrid Fan Token.</p>
<h2 id="h2-David20Barral374887"><a name="David Barral" class="reference-link"></a><span class="header-link octicon octicon-link"></span>David Barral</h2><p>La storia di David Barral, ex attaccante del Real Madrid B, coinvolgimento nel cripto e nello sport è interessante. Questo perché è il primo giocatore a accettare <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> (BTC) come il suo stipendio. Questo è significativo poiché è stato il primo accordo criptato che coinvolge il pagamento in valute digitali nella storia del calcio spagnolo.</p>
<h2 id="h2-Paul20Pogba525123"><a name="Paul Pogba" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Paul Pogba</h2><p>Pogba è noto per promuovere diversi progetti digitali che coinvolgono sia criptovalute che token non fungibili. Ad esempio, è stato ambasciatore di Cryptodragons che ha però suscitato scalpore sui social media poiché molti investitori hanno perso i loro fondi a causa del notevole deprezzamento degli asset digitali nel corso degli anni.</p>
<h2 id="h2-Conclusion10298"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Ronaldinho ha negato il suo coinvolgimento <a href="https://www.gate.io/learn/articles/pyramid-and-ponzi-schemes/154" target="_blank">in uno schema a piramide criptovalutaria</a> dove gli investitori hanno perso oltre 61 milioni di dollari. Invece, ha anche sostenuto di essere una vittima dell’inganno che ha utilizzato le sue immagini e il suo nome senza autorizzazione. Tuttavia, Ronaldinho non è l’unico calciatore a partecipare a progetti cripto. Kylian Mbappe, Cristiano Ronaldo, Luis Suarez, Lionel Messi, Roberto Carlos e Antoine Griezmann sono esempi di altri calciatori interessati alle criptovalute.</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 venga referenziato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div>