TWV0IGRlIG9wcmljaHRlciBnZWFycmVzdGVlcmQsIGthbiBUT04ta2V0ZW4gZ2V2YWFyIGluIHZlaWxpZ2hlaWQgdmVyYW5kZXJlbj8=

2024-08-28, 07:48

<p><img src="https://gimg2.gateimg.com/image/article/17248311201690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR934292"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Volgens Franse mediaberichten van 25 augustus is Pavel Durov, oprichter en CEO van Telegram, gearresteerd op de luchthaven van Parijs Bourget op verdenking van 12 misdrijven.</p>
<p>Na het nieuws brak, veroorzaakte het snel marktpaniek en sterke risicobeperking. De TON coin-prijs daalde in korte tijd naar een laagste punt van $5,246, met een maximale daling van bijna 23% in 24H. TVL daalde van $508M naar een laagste punt van $325M.</p>
<p>Het TON-ecosysteem wordt verwacht dit negatieve effect te verlichten door gebruik te maken van zijn onafhankelijkheid van Telegram in juridische operaties, evenals zijn gedecentraliseerde aard en onafhankelijke ontwikkelingspad.</p>
<h2 id="h2-Introductie995283"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Het recente nieuws over Pavel Durov, de oprichter en CEO van Telegram, die in Frankrijk werd gearresteerd, kwam als een donderslag bij heldere hemel en veroorzaakte snel een enorme schok in de cryptocurrency gemeenschap, vooral de TON publieke keten die nauw verbonden is met Telegram. De prijs hiervan kreeg een zware klap en daalde aanzienlijk.</p>
<p>Dit artikel zal de ins en outs van het incident analyseren en de daaropvolgende impact op het TON-ecosysteem onderzoeken.</p>
<h2 id="h2-Oprichter20gearresteerd20geconfronteerd20met20meerdere20strafrechtelijke20aanklachten704520"><a name="Oprichter gearresteerd, geconfronteerd met meerdere strafrechtelijke aanklachten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Oprichter gearresteerd, geconfronteerd met meerdere strafrechtelijke aanklachten</h2><p>Op 24 augustus werd Pavel Durov, oprichter en CEO van Telegram, gearresteerd op de luchthaven van Parijs Bourget op beschuldiging van samenzwering met illegale activiteiten.</p>
<p>Het Franse Openbaar Ministerie, dat Durov heeft vastgehouden, verklaarde dat Durov wordt beschuldigd van twaalf misdrijven, waaronder samenzwering met illegale activiteiten, weigeren informatie aan autoriteiten te verstrekken, witwassen van geld, banden met criminele bendes en het aanbieden van versleutelingsdiensten zonder aangifte.<img src="https://gimg2.gateimg.com/image/article/17248311791.jpg" alt=""><br>Bron: openbare informatie</p>
<p>Specifiek heeft het onderzoek naar seksuele uitbuiting van kinderen de Franse OFMIN-agentschap ertoe aangezet om een huiszoekingsbevel uit te vaardigen voor Durov. TF1 TV speculeert dat hij te maken zal krijgen met meerdere aanklachten, waaronder terrorisme, drugshandel, samenzwering om misdrijven te plegen, fraude, witwassen van geld en mogelijk meer. Gezien zijn dubbele nationaliteit kan hij tot twintig jaar gevangenisstraf krijgen.</p>
<p>Bijzonder opmerkelijk is het standpunt dat naar voren wordt gebracht door Yekaterina Mizulina, het hoofd van de Russische Internet Security Alliance, die van mening is dat achter de arrestatie van Durov mogelijk verborgen druk van de Verenigde Staten schuilgaat, gericht op het aanvallen van de supermunt. <a href="/price/toncoin-ton" rel="nofollow noopener noreferrer" target="_blank">Toncoin</a> (TON) dat op Telegram circuleert, om zo het sanctiebeleid van de Securities and Exchange Commission (SEC) tegen TON voort te zetten. Ondertussen verklaarde de Franse president Macron dat de arrestatie van Durov in het justitieel onderzoek geen politieke motieven had.</p>
<p>De verklaringen van verschillende landen voegen ongetwijfeld meer politieke en economische complexiteit toe aan het evenement.</p>
<p>Nadat het nieuws bekend werd, hoewel TON een verklaring heeft afgegeven om ‘iedereen gerust te stellen dat de TON-gemeenschap sterk en volledig operationeel blijft’, kon het de marktpaniek niet stoppen. De prijs van de TON-munt daalde in korte tijd naar een dieptepunt van $5.246 met een maximale daling van meer dan 23% in 24 uur. TVL daalde van $508 miljoen naar een dieptepunt van $325 miljoen.</p>
<p>Op de schrijfdatum is de munt prijs iets gestegen en gestabiliseerd en schommelt rond $5.41.<br><img src="https://gimg2.gateimg.com/image/article/17248312052.jpg" alt=""><br>Bron: Gate.io</p>
<h2 id="h2-Met20meerdere20regelgevende20inperkingen20is20TON20de20volgende20Tornado20of20BNB804057"><a name="Met meerdere regelgevende inperkingen, is TON de volgende ‘Tornado’ of ‘BNB’?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Met meerdere regelgevende inperkingen, is TON de volgende ‘Tornado’ of ‘BNB’?</h2><p>Terugkijkend op hun verleden, zijn Durov en TON herhaaldelijk getroffen door regelgevende maatregelen, wat marktpaniek veroorzaakt.</p>
<p>Durov trad eerder af en richtte Telegram op vanwege zijn verzet tegen de censuur van Rusland op zijn vroege socialemediaplatform VK, wat leidde tot gespannen relaties met de Russische overheid. Begin 2018 lanceerde Telegram officieel een project genaamd TON en wist succesvol $1,2 miljard op te halen bij bekende investeringsinstellingen, waaronder Sequoia Capital, Benchmark, Kleiner Perkins en Lightspeed, via een initial coin offering (ICO) strategie.</p>
<p>Echter, in oktober 2019, binnen een maand na de release van de testnetcode van het TON-project, heeft de Amerikaanse Securities and Exchange Commission (SEC) bepaald dat de financiering van TON-tokens in wezen gelijk stond aan illegale en ongereguleerde uitgifte van effecten. Als reactie op deze situatie heeft de SEC snel actie ondernomen om te voorkomen dat Telegram deze digitale tokens op de Amerikaanse markt verkoopt. Stephanie Avakian, het gezamenlijke hoofd van de handhavingsafdeling, verklaarde dat dit bedoeld was om illegale verkoop te beteugelen.</p>
<p>Vanaf mei 2020 heeft Pavel Durov, de oprichter van Telegram, besloten om het TON-project op te schorten en het proces van terugbetaling aan investeerders te starten, met uiteindelijk een terugbetaling van ongeveer 72% van de fondsen, in totaal $1.2B. Ondertussen betaalde Telegram ook een boete van $18.5 miljoen aan de SEC, maar heeft tijdens het proces de beschuldigingen van de SEC niet direct toegegeven of ontkend.<br><img src="https://gimg2.gateimg.com/image/article/17248312373.jpg" alt=""><br>Bron: SEC</p>
<p>Vervolgens droeg Pavel Durov de controle over het TON-project over aan de gemeenschap. Gezien de openheid van de TON-code werd <a href="/price/toncoin-ton" target="_blank" class="blog_inner_link">Toncoin</a> (TON) geboren en kreeg het project eind 2021 officiële erkenning van Pavel Durov.</p>
<p>De recente veroordeling en arrestatie van Durov herinnert ons aan vergelijkbare glen in het verleden waarin hij werd onderworpen aan regelgevende onderdrukkingen. Nadat CZ een hoge boete had betaald aan de Amerikaanse autoriteiten wegens witwaspraktijken, <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> hersteld van zijn inzinking en heeft zijn opwaartse trend hervat; daarentegen is het privacybeschermingsprotocol Tornado Cash aangepakt door Amerikaanse regelgevende instanties wegens niet-naleving, en verschillende beurzen hebben ook de TORN-token onder druk verwijderd.</p>
<p>In feite is de zaak Durov gecompliceerder dan CZ, Ripple en Tornado, dus het blijft nog te zien welke weg TON, die nauw met hen verbonden is, zal nemen.</p>
<h2 id="h2-Na20het20doorlopen20van20allerlei20wendingen20en20bochten20is20de20TON20Chain20steeds20veerkrachtiger20geworden595630"><a name="Na het doorlopen van allerlei wendingen en bochten is de TON Chain steeds veerkrachtiger geworden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Na het doorlopen van allerlei wendingen en bochten is de TON Chain steeds veerkrachtiger geworden</h2><p>Na de arrestatie van Durov spraken prominente figuren uit de technologie- en mediaindustrie, zoals Elon Musk en Tucker Carlson, zich uit voor Durov en uitten zij hun stevige steun.</p>
<p>Deze actie resoneerde binnen het TON (Telegram Open Network) ecosysteem. Diverse bekende projecten zoals DOGS, Hamster Network, TON Society, enz., hebben hun steun betuigd voor de voortdurende ontwikkeling van het TON-ecosysteem, waarbij ze de veerkracht en eenheid van het ecosysteem aantoonden.<img src="https://gimg2.gateimg.com/image/article/17248312704.jpg" alt=""><br>Bron: @ton_society</p>
<p>Vervolgens ontstond er een steunbeweging met het thema ‘FreePavel’ in de cryptogemeenschap, die zich wijd verspreidde via kanalen zoals X platform. Aanhangers verzamelden zich tot een onmiskenbare kracht door te delen en steun te betuigen, waarbij de cryptogemeenschap haar streven naar vrijheid en rechtvaardigheid toonde.</p>
<p>Ongetwijfeld stuurt de arrestatie van Durov een duidelijk signaal naar degenen die zich bezighouden met illegale activiteiten op het Telegram-platform, en weerspiegelt het ook de vastberadenheid van toezichthoudende instanties om het toezicht op communicatietoepassingen te versterken. Zo verklaarde de Indiase regering later dat ze onderzoek doet naar mogelijk misbruik van Telegram bij criminele activiteiten, met name afpersing en gokken. Als de onderzoeksresultaten ongunstig zijn, kan de toepassing het risico lopen te worden verboden.</p>
<p>Echter, hoewel het Telegram-platform het risico loopt op gebruikersverloop vanwege de arrestatie van de oprichter, wordt verwacht dat het TON-ecosysteem dit negatieve effect zal verzachten door gebruik te maken van zijn onafhankelijkheid van Telegram in juridische operaties, evenals zijn gedecentraliseerde aard en onafhankelijke ontwikkelingspad. Het laatste nieuws laat zien dat Durov mogelijk al zo vroeg als woensdag lokale tijd wordt vrijgelaten. Natuurlijk, als onderzoekers voldoende bewijs ontdekken tijdens het verhoorproces, zal de vrijlatingstijd oncontroleerbaar worden.</p>
<p>Hoe dan ook, dit evenement zal het publieke belang en de aandacht voor versleutelde communicatie, gedecentraliseerde financiën en de samenleving stimuleren, wat de ontwikkeling van het hele gedecentraliseerde blockchain-netwerkgebied bevordert.</p>
<p>Kortom, hoewel TON en het gehele <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> kan tijdelijk onder druk staan, maar op de lange termijn zal de verdieping van het gedecentraliseerde concept een onuitputtelijke drijvende kracht worden voor de ontwikkeling van de industrie. Net zoals vergelijkbare gebeurtenissen in het verleden vaak gepaard gaan met kortetermijnmarktfluctuaties en langetermijnreflecties, wordt verwacht dat het TON-ecosysteem na deze uitdaging nog veerkrachtiger vitaliteit zal tonen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io Onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herposten van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>