Q29uIGlsIGZvbmRhdG9yZSBhcnJlc3RhdG8sIHB1w7IgbGEgY2F0ZW5hIFRPTiB0cmFzZm9ybWFyZSBpbCBwZXJpY29sbyBpbiBzaWN1cmV6emE/

2024-08-28, 07:48

<p><img src="https://gimg2.gateimg.com/image/article/17248311201690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR793319"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Secondo i rapporti dei media francesi del 25 agosto, Pavel Durov, fondatore e CEO di Telegram, è stato arrestato all’aeroporto di Parigi Bourget per sospetto di 12 crimini.</p>
<p>Dopo la diffusione della notizia, ha rapidamente scatenato il panico di mercato e una forte avversione al rischio. Il prezzo della moneta TON è sceso a un minimo di $5,246 in breve tempo, con una caduta massima di quasi il 23% in 24 ore. Il TVL è sceso da $508M a un minimo di $325M.</p>
<p>Si prevede che l’ecosistema TON attenuerà questo impatto negativo sfruttando la sua indipendenza da Telegram nelle operazioni legali, nonché la sua natura decentralizzata e il percorso di sviluppo indipendente.</p>
<h2 id="h2-Introduzione368730"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Le recenti notizie su Pavel Durov, il fondatore e CEO di Telegram, che è stato arrestato in Francia, sono state come un fulmine a ciel sereno, causando rapidamente un’enorme shock nella comunità delle criptovalute, in particolare la catena pubblica TON strettamente legata a Telegram, il cui prezzo ha subito un duro colpo e è crollato significativamente.</p>
<p>Questo articolo analizzerà i dettagli dell’incidente ed esplorerà il suo successivo impatto sull’ecosistema di TON.</p>
<h2 id="h2-Fondatore20arrestato20affronta20molteplici20accuse20penali374854"><a name="Fondatore arrestato, affronta molteplici accuse penali" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fondatore arrestato, affronta molteplici accuse penali</h2><p>Il 24 agosto, Pavel Durov, fondatore e CEO di Telegram, è stato arrestato all’aeroporto di Parigi Bourget con l’accusa di cospirazione con attività illegali.</p>
<p>L’ufficio del procuratore francese, che ha detenuto Durov, ha dichiarato che Durov è accusato di dodici crimini, tra cui cospirazione con attività illegali, rifiuto di fornire informazioni alle autorità, riciclaggio di denaro, associazione con bande criminali e fornitura di servizi di crittografia senza dichiarazione.<img src="https://gimg2.gateimg.com/image/article/17248311791.jpg" alt=""><br>Origine: informazioni pubbliche</p>
<p>In particolare, l’indagine sull’abuso sessuale dei minori ha spinto l’agenzia francese OFMIN a emettere un mandato di perquisizione per Durov. La TV TF1 ipotizza che affronterà diverse accuse, tra cui terrorismo, traffico di droga, cospirazione per commettere crimini, frode, riciclaggio di denaro e forse altro. Considerando la sua doppia nazionalità, potrebbe affrontare fino a venti anni di carcere.</p>
<p>Particolarmente degna di nota è la visione proposta da Yekaterina Mizulina, capo dell’Alleanza per la sicurezza su Internet russa, che ritiene che dietro l’arresto di Durov possa esserci una pressione nascosta da parte degli Stati Uniti, mirata a attaccare la super valuta <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a>(TON) circolanti su Telegram, al fine di proseguire la politica delle sanzioni della Securities and Exchange Commission (SEC) contro TON. Nel frattempo, il presidente francese Macron ha dichiarato che l’arresto di Durov nell’inchiesta giudiziaria non ha coinvolto alcun motivo politico.</p>
<p>Le dichiarazioni dei vari paesi aggiungono indubbiamente maggiore complessità politica ed economica all’evento.</p>
<p>Dopo la diffusione della notizia, anche se TON ha rilasciato una dichiarazione per “assicurare a tutti che la comunità TON rimane forte e pienamente operativa”, non è riuscita comunque a fermare il panico di mercato. Il prezzo della moneta TON è sceso a un minimo di $5.246 in breve tempo con una caduta massima di oltre il 23% in 24 ore. Il TVL è sceso da $508M a un minimo di $325M.</p>
<p>Alla data di scrittura, il prezzo della moneta è leggermente rimbalzato, si è stabilizzato e fluttuato intorno a $5.41.<img src="https://gimg2.gateimg.com/image/article/17248312052.jpg" alt=""><br>Sorgente: Gate.io</p>
<h2 id="h2-Con20molte20regolamentazioni20severe20TON2020il20prossimo20tornado20o20BNB149459"><a name="Con molte regolamentazioni severe, TON è il prossimo “tornado” o “BNB”?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Con molte regolamentazioni severe, TON è il prossimo “tornado” o “BNB”?</h2><p>Riflettendo sulla loro storia passata, Durov e TON sono stati ripetutamente colpiti da misure regolamentari, causando panico di mercato.</p>
<p>Durov si è dimesso in precedenza e ha fondato Telegram a causa dell’opposizione alla censura della sua prima piattaforma di social media VK da parte della Russia, cosa che ha portato a relazioni tese con il governo russo. All’inizio del 2018, Telegram ha ufficialmente lanciato un progetto chiamato TON e ha raccolto con successo fino a $1,2 miliardi da note istituzioni di investimento, tra cui Sequoia Capital, Benchmark, Kleiner Perkins e Lightspeed, attraverso una strategia di offerta iniziale di monete (ICO).</p>
<p>Tuttavia, entro ottobre 2019, nel giro di un mese dal rilascio del codice di prova del progetto TON, la Securities and Exchange Commission (SEC) degli Stati Uniti ha stabilito che il finanziamento dei token TON era essenzialmente equivalente a attività di emissione di titoli illegali e non regolamentati. In risposta a questa situazione, la SEC ha agito rapidamente per impedire a Telegram di vendere questi token digitali sul mercato statunitense. Stephanie Avakian, il capo congiunto del dipartimento di applicazione delle leggi, ha dichiarato che ciò era per frenare le vendite illegali.</p>
<p>A maggio 2020, Pavel Durov, il fondatore di Telegram, ha preso la decisione di sospendere il progetto TON e ha avviato il processo di restituzione dei fondi agli investitori, riuscendo alla fine a ottenere un rimborso pari a circa il 72% dei fondi, per un totale di 1,2 miliardi di dollari. Nel frattempo, Telegram ha anche pagato una multa di 18,5 milioni di dollari alla SEC, ma non ha ammesso o negato direttamente le accuse della SEC durante il processo.<img src="https://gimg2.gateimg.com/image/article/17248312373.jpg" alt=""><br>Origine: SEC</p>
<p>Successivamente, Pavel Durov ha trasferito il controllo del progetto TON alla comunità. Date l’apertura del codice TON, è nato <a href="/price/toncoin-ton" target="_blank" class="blog_inner_link">Toncoin</a> (TON), e il progetto ha ricevuto il riconoscimento ufficiale da parte di Pavel Durov alla fine del 2021.</p>
<p>La recente condanna e l’arresto di Durov ci ricorda casi simili del passato in cui è stato soggetto a repressioni regolamentari. Dopo che CZ ha raggiunto un accordo con le autorità degli Stati Uniti per una multa elevata su accuse di riciclaggio di denaro, … <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> si è ripreso dalla sua caduta e ha ripreso la sua tendenza al rialzo; Al contrario, il protocollo di protezione della privacy Tornado Cash è stato colpito dalle agenzie di regolamentazione statunitensi per la mancanza di conformità, e varie borse hanno anche ritirato il token TORN sotto pressione.</p>
<p>In realtà, il caso Durov è più complesso di CZ, Ripple e Tornado, quindi rimane da vedere quale percorso prenderà TON, che è strettamente correlato a loro.</p>
<h2 id="h2-Dopo20aver20attraversato20svolte20e20sorprese20la20catena20TON2020diventata20sempre20pi20resiliente883578"><a name="Dopo aver attraversato svolte e sorprese, la catena TON è diventata sempre più resiliente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dopo aver attraversato svolte e sorprese, la catena TON è diventata sempre più resiliente</h2><p>Dopo l’arresto di Durov, importanti figure del settore tecnologico e dei media, come Elon Musk e Tucker Carlson, si sono schierate a favore di Durov e hanno espresso il loro ferreo sostegno.</p>
<p>Questa azione ha risuonato all’interno dell’ecosistema TON (Telegram Open Network). Diversi progetti ben noti come DOGS, Hamster Network, TON Society, ecc., hanno espresso il loro sostegno per il continuo sviluppo dell’ecosistema TON, dimostrando la resilienza e l’unità dell’ecosistema.<img src="https://gimg2.gateimg.com/image/article/17248312704.jpg" alt=""><br>Fonte: @ton_society</p>
<p>Successivamente, è emerso un movimento di supporto con il tema di “FreePavel” nella comunità delle criptovalute, diffuso ampiamente attraverso canali come la piattaforma X. I sostenitori si sono riuniti in una forza innegabile attraverso la condivisione e il supporto, dimostrando la ricerca di libertà e giustizia della comunità delle criptovalute.</p>
<p>Senza dubbio, l’arresto di Durov invia un segnale deciso a coloro che si dedicano a attività illegali sulla piattaforma Telegram, e riflette anche la determinazione delle agenzie di regolamentazione nel rafforzare la supervisione delle applicazioni di comunicazione. Ad esempio, il governo indiano ha successivamente dichiarato di essere impegnato in un’indagine sul possibile abuso di Telegram in attività criminali, soprattutto estorsioni e gioco d’azzardo. Se i risultati dell’indagine non sono favorevoli, l’applicazione potrebbe correre il rischio di essere vietata.</p>
<p>Tuttavia, anche se la piattaforma Telegram affronta il rischio di perdere utenti a causa dell’arresto del suo fondatore, ci si aspetta che l’ecosistema TON mitighi questo impatto negativo sfruttando la sua indipendenza da Telegram nelle operazioni legali, nonché la sua natura decentralizzata e il percorso di sviluppo indipendente. Le ultime notizie mostrano che Durov potrebbe essere rilasciato già mercoledì ora locale. Naturalmente, se gli investigatori scoprono prove sufficienti durante il processo di interrogatorio, il momento del rilascio diventerà incontrollabile.</p>
<p>In ogni caso, questo evento stimolerà l’interesse pubblico e l’attenzione alla comunicazione crittografata, alle finanze decentralizzate e alla società, promuovendo lo sviluppo dell’intero settore della rete blockchain decentralizzata.</p>
<p>In breve, anche se TON e l’intero <a href="/price" rel="nofollow noopener noreferrer" target="_blank">mercato delle criptovalute</a> Potrebbe essere temporaneamente sotto pressione, ma a lungo termine, il consolidamento del concetto decentralizzato diventerà una forza trainante inesauribile per lo sviluppo del settore. Proprio come eventi simili del passato sono spesso accompagnati da fluttuazioni di mercato a breve termine e riflessioni a lungo termine, ci si aspetta che l’ecosistema TON dimostri ancora più resilienza vitale dopo questa sfida.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Carl Y.</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 su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>