R8O8bmzDvGsgRmxhxZ8gfCBCbGFja1JvY2sgxLBsayBCaXRjb2luIMOWemVsIEfDvHZlbmluaSBCYcWfbGF0dMSxLCBNYWtlckRBTyBEb2xhcmRhbiBBeXLEsWxtYXnEsSBQbGFubMSxeW9yIHZlIEV0aGVyZXVtIEZpbmFsIFRlc3RuZXQgWWF5xLFuYSBCYcWfbMSxeW9y

<span> 
<p>
	<span style="background-color:#F5F5F5;"> </span> 
</p>
<p>
	<span style="font-size:11pt;background-color:transparent;vertical-align:baseline;"><span><img onerror="this.className=`errimg`" src="https://lh3.googleusercontent.com/Cw-8fFnVEth0jQa_PxWPjH972WOJz8jqnsb--ZLIj4C42VF5fT-YEyqEY7HPXnDC-HfmqUkxMNt13DE-RrO9fyAdLjIOQduo0jcQUoladRHiFHuleO19_ujWuVRPY2EHHM7KT9zYpfuOfW-uCpQnrDklazGQZG5h5tWtiC-iGoVawy_7ZMibrKWVrw" width="602" height="301" /></span></span> 
</p>
<h2 style="background-color:#f5f5f5;">
	<span style="font-size:17pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Bugünün Manşeti - BlackRock, doğrudan <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">bitcoin</a> maruziyeti sunan özel bir güven başlattı: Block Raporu</span> 
</h2>
<br />
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:11pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh4.googleusercontent.com/qM3lgPoiwSnmMHA6MlDJAsdzLcSXSj-lgFZPyXRC-AbOUFv7shOPdq52OUV6Q7xTRvtlNrZDd7qdEoVpjZ0pHHkHHlBR0ggTE0SMwlZhdnEn2Q2quQKnECk0S6PU2VLJHSoH1h4xehi62-A6V6waP_FlbaLjBAPCUKM6MB21TiSMq3TUstBM204MPg" width="602" height="412" /></span></span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;vertical-align:baseline;">BlackRock, ABD merkezli kurumsal müşterilerine dünyanın en popüler kripto para birimine doğrudan maruz kalmalarını sağlamak için bir spot <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">bitcoin</a> özel tröstünü başlattı. Güven, BlackRock'un <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">bitcoin</a> fiyatına doğrudan maruz kalma sunan ilk ürünü olacak.</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;vertical-align:baseline;">BlackRock yaptığı açıklamada,</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;vertical-align:baseline;">"Dijital varlık pazarındaki keskin düşüşe rağmen, bazı kurumsal müşterilerimizden teknoloji ve ürün yeteneklerimizi kullanarak bu varlıklara nasıl verimli ve uygun maliyetli bir şekilde erişebileceğimiz konusunda hala büyük ilgi görüyoruz."</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;vertical-align:baseline;">2021'in başlarında BlackRock, Global Allocation fonunun CME'nin <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">bitcoin</a> vadeli işlemleri teklifi aracılığıyla <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">bitcoin</a>'e bir miktar maruz kaldığını iddia etti. Bu, Blackrock Global Allocation Fund da dahil olmak üzere iki BlackRock fonunun düzenleyici dosyalarda CME'nin <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">bitcoin</a> vadeli işlem ürünü yoluyla potansiyel olarak kripto pazarlarına maruz kalacaklarını belirtmesinden iki ay sonra geldi.</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;vertical-align:baseline;">Yaklaşık 9 trilyon dolarlık müşteri fonunu yöneten BlackRock, hizmeti sağlamak için Coinbase Prime'ı kullanacak.</span> 
</p>
<br />
<br />
<br />
<h2 style="background-color:#f5f5f5;">
	<span style="font-size:17pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Günün Tablosu - Toplam Stabilcoin Arzı 150 Milyar Doları Geçti</span> 
</h2>
<br />
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:11pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh4.googleusercontent.com/YUKOWckw00R3xI-Y0QqOFWHPFdOuHaJ_Wt88_cJSgkw9FzKBCrg3WJ1sOIn0TF8B_8VI5QQzjx-sLhHY_xvh9GmSsuHSpHPSwtik_Opv1gN96z2TbsR3GqxF7v7ehVuIyVIa1XKIIx_eO0ywcE7myvqdhWQPo3vG7xQmeCgy-ui8sM5F4MA1WIQyAA" width="602" height="339" /></span></span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Toplam ödenmemiş stablecoin arzı, Ağustos 2022'de 150 milyar doları aştı. Ticaret hacminin son 7 günde %46 arttığını belirtmekte fayda var.</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"> </span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Bu yazı itibariyle,</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">bitcoin</a> (BTC), son 24 saatte %4,06 düşüşle 23.831 $ civarında el değiştiriyor.</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Ether (ETH) ise aynı dönemde %2.3 düşüşle  1.881 $  işlem görüyor.</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Cardano (ADA) %3,17, Solana (SOL) %-4,76, Polkadot (DOT) %3,37, Avalanche (AVAX) %4,46 ve Cosmos (ATOM) %3.81. ile büyük altcoinler de kırmızıda işlem görüyor. </span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"> </span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">En çok yükselenler:</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Energy Web (EWT) 3,93 $ (+%48,28),</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Ankr Network(ANKR) 0.0486 $ (+38.58%),</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Maple Finance (MPL) 20,58 $ (+%15,95).</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">En çok düşebnler:</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">PolySwarm (NCT) 0,0180 $ (-11,83 $),</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Injective Protokol (INJ) 1,98 $ (-10,23 $),</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Refereum (RFR) 0,00737 $ (-11,96 ABD Doları).</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">bitcoin</a> (BTC) son 24 saatte %4,39 düşerken, Ether (ETH) %2,55 düştü.</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Teknik görünüm açısından, BTC Perşembe günü 24.269 $ - 24.298 $ haftalık direnç bölgesini sürdüremedi. Bu arada, Ethereum'un son test ağı birleştirmesinin başarılı bir şekilde başlatılması, kripto para birimini aylık 1.918 $ - 1.947 $ direnç bölgesinin üzerine çıkaramadı.</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Hem BTC hem de ETH'deki 20 günlük EMA'nın yükselmesiyle, boğalar kendi direnç bölgelerini kırmaya çalıştığında ayılar muhtemelen daha fazla zayıflıktan yararlanacak.</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;">Kripto para piyasası, ABD hisse senedi piyasası ile yüksek oranda ilişkili olduğundan, ikincisinin performansına dikkat etmek önemlidir. Yıl için hala %18 düşüşte olan Nasdaq %0,58 düşerken S&amp;P 500 %0,07 düştü. Dow Jones Sanayi Endeksi %0,08 arttı.</span> 
</p>
<br />
<br />
<br />
<br />
<h2 style="background-color:#f5f5f5;">
	<span style="font-size:17pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Günün Influencer’ı - MakerDAO Kurucusu, DAI'yi Tornado Cash Fallout Ortasında Dolar Peg Düşürmeye Çağırdı: CoinDesk Raporu</span> 
</h2>
<br />
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:11pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh5.googleusercontent.com/LJ4bZK7ce6FLEAcx_8W1v-0hWUDJL00O8GnI5xZnJwBnpOpXX4akg7v87mcc-Wwjjv2emXMtHi4tBoAOiwUAvaercIaTCDQiaxhBabRq_GIu3vvojUfPnn_T99HpOzzOwBP8cCh-dDpyMJFuQBxMTtZ4oSv5Wf5mpiRFNFUAlqCeCdXXoaosUDxrAw" width="600" height="368" /></span></span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;vertical-align:baseline;">Perşembe günü CoinDesk ile yaptığı röportajda Rune Christensen, ABD Hazine Bakanlığı'nın yaptırım uygulayan token karıştırıcı Tornado Cash'in "DeFi için yeni bir dö<a href="https://www.gate.io/trade/XEM_USDT" target="_blank">nem</a>" başlatıyor olabileceğini ve "herhangi bir protokolün yaptırım alma olasılığının kapısını açtığını" söyledi. akıllı bir sözleşmeyi onaylama kararı "yararsız ve anlamsızdı", çünkü hükümetin yasağını uygulaması imkansız olacak.</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;vertical-align:baseline;">Bu hafta, MakerDAO topluluğu üyeleri, yaptırımın "temel" cüzdanlarını etkilemesi durumunda bir "acil durum planı" hazırlamaya başladı. Özellikle endişe verici olan, mevzuata uyumlu Merkez Konsorsiyumu tarafından çıkarılan bir stabilcoin olan USDC'nin büyük miktarıdır.</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;vertical-align:baseline;">DAI'nin üçte birinden fazlası USDC tarafından desteklenirken, rezervlerinin yaklaşık dörtte biri ether'de (ETH). ETH veya USDC'nin Tornado ile etkileşime girdiği tespit edilirse, dondurulabilir ve Maker'da bir eksiklik olabilir.</span> 
</p>
<br />
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;vertical-align:baseline;">DeFi'yi daha büyük, geleneksel ekonomiye bağlamak için MakerDAO, "gerçek dünya varlıkları" dediği şeyleri entegre etmek için çalışıyor. Bu, ipotek sektörüne girmeyi ve ayrıca potansiyel olarak insanların kripto dışı varlıkları teminat altına almalarına izin vermeyi içerir.</span> 
</p>
<br />
<br />
<br />
<br />
<h2 style="background-color:#f5f5f5;">
	<span style="font-size:17pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Dünün Dedikoduları - #Ethereum Final Testnet Merge Yayınlanıyor, #Pudgy Penguin NFT Taban Fiyatı Ürün Duyurusunda Artıyor</span> 
</h2>
<br />
<br />
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:11pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh4.googleusercontent.com/-fLyewF3vOXFTw55PNOzma32_X6CH8H4Ky_cyFCfdTVbMKZTwiIPLiZovtl2EK1ZvdZBXLKU-QxaBnE183z589RmpUG7JiWCWLXfuvOG6cK5F_WKmwvfFrFqA-5gmmkG6Ov9rOm4qbgApUG07N4pw9IeIcqIfkuQ6gIQUj5WMzSDFRniIaAoPGf7XA" width="602" height="339" /></span></span> 
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<h3 style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:13pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Şüpheli Tornado Cash geliştiricisi Amsterdam'da tutuklandı</span> 
</h3>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh4.googleusercontent.com/NfvnBs8QVWnIoGRTAoWDx2dgD_11nmcyUT2VQT2apWIp88JIJIgNKni0AloO5YHhAtTKsZ8oJcGhSRtqGOSYuKkyDplYu-vHoCk3VD4zb0lqd_fA6MEcX12JoT_qkHvRhmnyl7bapzYLYExxRJWOkuHANsx89lBYGw6YYVAo2NQME0todchiqoBHCQ" width="602" height="307" /></span></span> 
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<h3 style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:13pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Ethereum'un Üçüncü ve Son Testnet Merge Goerli'de Yayınlanıyor</span> 
</h3>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh4.googleusercontent.com/dP4P4nJ-T6iKcSm81panzr7y3JZmpJcphbNLRK34BFO0ViFfgeS5nBTl1BYUMpWikoQ4BtpVFSU25frUHaqJACYjWixTFmBD8uizWZZt9Vo_ykA2TxCpqPDo_CTrvJvKrjZGlSrVTROFwzMit4G-4EUvwvowk5r_oeKXyFrWg-j-BTrK9Sym4mFfEw" width="602" height="376" /></span></span> 
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<h3 style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:13pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Blur Finance'in iddiaya göre rugpull ile yatırımcıların toplam 600 bin dolarlık zararı var</span> 
</h3>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh5.googleusercontent.com/2CHSWyTNfTAUYKxFl9JkeINWvq9hPNz9fy43tzmgg2_FCNzx71NL4SXuFh3oosg7dTueu95kH2cBGqMj536_c3vsjt78npfIfkvcaG6b6sfxMdtiCJNgjY9Y0VB7XfzDXyNBZlhbqvrENiiw0nrZspV4zkUrqEj9hVz6mmm7EymAG-s1yQ1c0TU15g" width="602" height="339" /></span></span> 
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<h3 style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:13pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Unstoppable Finance, DeFi Cüzdanı Oluşturmak için 12.8 Milyon Dolar Artırdı</span> 
</h3>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh5.googleusercontent.com/CWhdm_uYH3wQylhuXRbgsV29RbaSPoTPoSo3VvTcdvIHXBkcRyq0pg0MVUFPhrOLis7SvPgYDZEPLeDEcJzwWHNW9oBEodN-Q5Vm2pTNHOefS0j1odbTpEAJHFYkX1HGNVa2qsQvQHufYfTIkQU-KlmIWEtNFaBl7pHFRqso1kt5AuXaNlE8q8VcMg" width="602" height="401" /></span></span> 
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<h3 style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:13pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Pudgy Penguins NFT Fiyatları, Yaratıcı IRL Oyuncaklarını Açıkladıktan Sonra Arttı</span> 
</h3>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh5.googleusercontent.com/XW7cWgp6PtoolOyEU319JzI1Bg1248X2nz-M-JJTbvcq74UQ3rZNyQRwBNAVfP3gA1-Y2yU0ei_cPjXk8uHyc7uZztr7CYanBXJbULm-ugZMANznMzs1Y27GleO7ovaf3OtGEpkZzSYpESPwfUsaDKBgRWH2OIqc3GUbWIRrHJj-C1R48y9ETr7eQA" width="602" height="331" /></span></span> 
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<h3 style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:13pt;background-color:transparent;font-weight:400;vertical-align:baseline;"><a href="https://www.gate.io/trade/BTC_USDT" target="_blank">bitcoin</a> madencisi Hut 8, ikinci çeyrekte 69 milyon dolarlık net zarar bildirdi</span> 
</h3>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh4.googleusercontent.com/uEoKQWpux_y6H4JKNCIwjDvutDw7WiUDCfHhfTmG-3iV1ORhHnAZvh6_FCW_dfet4mJz2ZSZhM5D4nNMcGy0xEGvfedY7gSHFv7a4ipxiZWiKp1LCXuhflyOK-7tIPeNAtiTGJZGe0QpTa7zzC_JFmY5bsn8mTsQIcQiChUsI-Qho5WNUUNSaLjidQ" width="600" height="380" /></span></span> 
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<h3 style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:13pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Core Scientific geliri yendi, ikinci çeyrekte net zarar bildirdi</span> 
</h3>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh5.googleusercontent.com/J2UlNjC1WSvGl9_aJc9doSFq1WGwCyIgon5P7cUC6z4tQpV59AlXFo4Li_HBYJQX6ij70v239zOfoSok_5p8jXalaKCfapV4qBkhRZU3WqI6PplUIClS3i-nw4PbrOrA7uo4fvKTiV9eJI66KMP4iOTI74Vf7zgK0njbSonBYUS2yQU_R19JULvhqA" width="602" height="357" /></span></span> 
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<h3 style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:13pt;background-color:transparent;font-weight:400;vertical-align:baseline;">DeFi odaklı ticaret uygulaması Structure El Salvador'da piyasaya sürüldü, daha fazla genişleme planlıyor</span> 
</h3>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh6.googleusercontent.com/rpzxwubhyVkgjCjTh9ADR-WUOaWUQCc4FY233Bba5sgUtmKOu9Cef7j3qSWhAERlJMz4TIVJ6uJB3MK-SV79_OQJCenJ6HakFbEc9WknXrlzpg5xRpIZ9C4Jg2Fw5zxJAndIu541AfWh8t1_IZxonYkL5e0vwshOVW116n8su-Dm-bsRuEWqnapIEw" width="602" height="400" /></span></span> 
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<h3 style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:13pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Buenos Aires, 2023'te Ethereum Validator Düğümlerini Dağıtacak</span> 
</h3>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh4.googleusercontent.com/0rgd_VL5hpo7eaWf3CP5BG-opokutrBVzzyPJOXmc53rZF1Aga1K54I9ZUD-9auDP5r0YCVXmUHvCKcJiwGwdHaz1Fmj8rf8cfKfFFyta3kcTFKMMHx8rzvDUpnrY1Ow_UDUt03DveFRPvIvil0B-CqtV6WQRE79aIk81Eo6IAQdr4HzI0bg_r2Scg" width="602" height="388" /></span></span> 
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<h3 style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:13pt;background-color:transparent;font-weight:400;vertical-align:baseline;">Hintli Yetkililer, Kripto Borç Veren Kasasının Varlıklarında Yaklaşık 46 Milyon Doları Dondurdu</span> 
</h3>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<br />
</p>
<p style="text-align:center;background-color:#f5f5f5;">
	<span style="font-size:12pt;background-color:transparent;vertical-align:baseline;"><span><img src="https://lh4.googleusercontent.com/yyakKVj4fEz2zEKbXxSQ1X-KWcCjcRUCCnCN1XdZbF0es337XDUb_ptxxcX09sRxcShGj2eiBaxCepZd_aEq3fsECdtL6eDxL9nghMxoCowHKAYEUTVoziSLmh461Dt3COatf1lFVMa3bi0JB_mJpUuwb5Bvwk2fA8XzVIb8Lxb0U0KYbwy9JaKgSA" width="600" height="154" /></span></span> 
</p>
<br />
<br />
<br />
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;font-weight:700;vertical-align:baseline;">Yazar: Gate.io Araştırmacısı Peter L.</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;font-weight:700;vertical-align:baseline;">Bu yazı sadece araştırmacının görüşlerini yansıtmakta olup herhangi bir yatırım tavsiyesi niteliği taşımamaktadır. Gate.io, bu makalenin tüm haklarını saklı tutar.</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;font-weight:700;vertical-align:baseline;">Gate.io'ya atıfta bulunulması koşuluyla makalenin yeniden yayınlanmasına izin verilecektir.</span> 
</p>
<p>
	<span style="font-size:12pt;background-color:#F5F5F5;font-weight:700;vertical-align:baseline;">Diğer tüm durumlarda, telif hakkı ihlali nedeniyle yasal işlem yapılacaktır.</span> 
</p>
<br />
</span>