RGFnZWxpamtzIG5pZXV3cyB8IEJsYXN0IE5ldHdvcmstcHJvYmxlbWVuIG9wZ2Vsb3N0LCBEZW5jdW4tdXBncmFkZXMgdmVybWluZGVyZGVuIGRlIGtvc3RlbiBtZXQgYmlqbmEgOTAlOyBPcHJpY2h0ZXIgdmFuIEJpdGNvaW4gRm9nIHZlcm9vcmRlZWxkIHZvb3Igd2l0d2FzcHJha3Rpamtlbg==

2024-03-14, 04:14

<p><img src="https://gimg2.gateimg.com/image/article/17103895881_9.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Het20Blastnetwerk20heeft20blokken20hersteld20en20integratieproblemen20opgelost20Dencunupgrade20verlaagt20de20kosten20van20ZkSync20Era20met208820Oprichter20van20Bitcoin20Fog20veroordeeld20tot205020jaar20gevangenisstraf20wegens20witwassen20van20geld82691"><a name="Crypto Daily Digest: Het Blast-netwerk heeft blokken hersteld en integratieproblemen opgelost; Dencun-upgrade verlaagt de kosten van ZkSync Era met 88%; Oprichter van Bitcoin Fog veroordeeld tot 50 jaar gevangenisstraf wegens witwassen van geld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Het Blast-netwerk heeft blokken hersteld en integratieproblemen opgelost; Dencun-upgrade verlaagt de kosten van ZkSync Era met 88%; Oprichter van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Fog veroordeeld tot 50 jaar gevangenisstraf wegens witwassen van geld</h2><p>Met betrekking tot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> Volgens gegevens van Farside Investor waren de uitstroom van Grayscale GBTC op 13 maart ongeveer $276,5 miljoen, de instroom van Bitwise Bitcoin Spot ETF (BITB) was $5,6 miljoen, de instroom van ARK 21Shares Bitcoin Spot ETF (ARKB) was $44,6 miljoen, en de instroom van Fidelity Bitcoin Spot ETF (FBTC) was $281,5 miljoen.</p>
<p>Na de lancering van het Blast-mainnet hebben problemen met punten en brugtijd ontevredenheid in de gemeenschap veroorzaakt. Vandaag verklaarde de officiële post van Blast op het X-platform dat de opschorting van de blokproductie gisteravond is opgelost, het netwerk de blokproductie heeft hervat en dat er zo snel mogelijk een probleemanalyserapport zal worden uitgebracht.</p>
<p>Pacman heeft ook vooruitgang geboekt bij het oplossen en bijwerken van eerdere gerelateerde problemen, waaronder:</p>
<ol>
<li><p>De vermindering van punten na de migratie van het Blast-mainnet;</p>
</li><li><p>Hoewel er een balans is op het mainnet, zien gebruikers nul punten per uur;</p>
</li><li><p>Er werden geen punten behaald, maar er worden wel getallen weergegeven;</p>
</li></ol>
<p>Een melding dat de bonus niet op tijd kan worden verkregen, hoewel het bedrag aan fondsen op het mainnet hetzelfde is als voorheen.</p>
<p>Het netwerk kan ook in de toekomst zorgen voor deze reparaties, waaronder:</p>
<ol>
<li><p>Beloningen die tijdens het conversieproces van het hoofdnetwerk worden gezien, zijn minder dan 10 keer;</p>
</li><li><p>De punten die worden verkregen na het storten in USDB zijn minder dan verwacht (verwacht wordt dat dit deze week wordt opgelost);</p>
</li><li><p>Veel dapps zijn begonnen met integreren met de punten API en hebben het dapp leaderboard gewijzigd om scores weer te geven voor alle dapps, in plaats van alleen gemarkeerde scores (verwacht wordt dat dit geoptimaliseerd wordt in de komende 10 dagen).</p>
</li></ol>
<p>De Dencun-upgrade is geïmplementeerd, en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> heeft officieel de Dencun hard fork upgrade geactiveerd op Beacon hoogte 8.626.176. Na de updates van de L2 netwerkversie ondersteunt EIP-4844 wordt ‘blob’ gebruikt in plaats van ‘calldata’. ZkSync Era is de eerste L2 die Blob gebruikt en Starknet ondersteunt het.</p>
<p>L2BEAT-onderzoeker donnoh.eth onthulde dat voordat Blob werd gebruikt, de kosten van de zkSync Era-sequencer daalden tot ongeveer 0,013 ETH. Na het gebruik van Blob bedroegen de kosten van het gebruik van Calldata ongeveer 0,115 ETH, een daling van ongeveer 88%.</p>
<p>Volgens het rapport van Cointelgraph is Roman Sterlingov, oprichter van Bitcoin Fog, een hybride crypto-service, in de Verenigde Staten veroordeeld voor witwassen van geld, samenspanning bij witwassen van geld, het exploiteren van een ongeautoriseerde valutatransmissiebedrijf en het schenden van de Currency Transmission Act van Washington D.C. De maximale straf voor deze aanklachten is 50 jaar gevangenisstraf en de veroordeling staat gepland voor 15 juli. De advocaat van Stringoff, Tok Ekeland, verklaarde in een bericht dat zijn team in beroep zou gaan.</p>
<p>Op basis van het bewijsmateriaal in de aanwijzingen opereerde Sterlingoff Bitcoin Fog tussen oktober 2011 en april 2021, wat volgens het Amerikaanse ministerie van Justitie (DOJ) een witwasservice is die wordt verstrekt aan ‘criminelen die proberen illegale winsten voor wetshandhavingsinstanties te verbergen’.</p>
<p>De dienst heeft meer dan 1,2 miljoen Bitcoins overgemaakt en de jury heeft besloten om de activa van het in beslag genomen Bitcoin Fog Fonds te confisqueren, inclusief 1.354 Bitcoins die worden aangehouden in de Bitcoin Fog Wallet en bijna $350.000 aan verschillende cryptocurrencies die worden aangehouden in de in beslag genomen Kraken-account.</p>
<h2 id="h2-Markttrends20BTC20handelt20horizontaal20op20een20hoog20niveau20en20het20Altcoinseizoen20is20begonnen233311"><a name="Markttrends: BTC handelt horizontaal op een hoog niveau en het Altcoin-seizoen is begonnen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC handelt horizontaal op een hoog niveau en het Altcoin-seizoen is begonnen.</h2><p>BTC handhaaft nog steeds een relatief hoog niveau van stabiliteit, wat een positief signaal is voor de hele cryptomarkt, aangezien Altcoins een gezamenlijke opwaartse trend beginnen te vertonen. Na de Cancun-upgrade gisteravond presteerde het ecosysteem van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> matig, terwijl STRK als eerste een daling ervoer. Deze situatie toont de interne differentiatie en volatiliteit van de cryptomarkt aan.</p>
<p>Met betrekking tot macro-economie schommelt de Amerikaanse aandelenmarkt met zwakke winsten, wat invloed kan hebben op het beleggerssentiment op de cryptomarkt. De toenemende correlatie tussen de cryptomarkt en de traditionele financiële markten maakt hen gevoeliger voor macro-economische factoren.</p>
<h3 id="h3-Markt20hotspots13737"><a name="Markt hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots</h3><ol>
<li><p>Het SOL-ecosysteem groeit snel: de token SOL in het <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Het ecosysteem heeft een opleving doorgemaakt en projecten zoals MOBILE, JUP, RAY, WIF en MYRO hebben een gezamenlijke opleving gezien. Na de Cancun-upgrade richtte de markt zich op het hypen van het SOL-ecosysteem, wat resulteerde in een omkering van de SOL/BTC wisselkoers.</p>
</li><li><p>AEVO gelanceerd: De lancering van AEVO heeft veel aandacht van de markt getrokken en de marktwaarde heeft de toonaangevende DYDX-project in de gecentraliseerde derivatenmarkt overtroffen. Dit heeft echter ook een wijdverbreid sentiment van short-selling in de markt teweeggebracht, waardoor AEVO-contracten negatieve rentes behouden, wat een onzekere marktreactie kan zijn op hun toekomstige ontwikkeling.</p>
</li></ol>
<p>Over het algemeen blijft de cryptomarkt schommelen onder invloed van diverse factoren. Beleggers moeten de markttrends nauwlettend in de gaten houden en op tijd hun beleggingsstrategie aanpassen om zich aan te passen aan marktveranderingen. Ondertussen zijn risicobeheer en assetdiversificatie ook factoren waar beleggers op moeten letten om om te gaan met de potentiële volatiliteit en risico’s die de markt met zich mee kan brengen.</p>
<h2 id="h2-Macro20SampP20en20Nasdaq20iets20lager20wereldwijde20marktconsolidatie20ruwe20olie20en20goud20blijven20stabiel961026"><a name="Macro: S&amp;P en Nasdaq iets lager, wereldwijde marktconsolidatie, ruwe olie en goud blijven stabiel" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: S&amp;P en Nasdaq iets lager, wereldwijde marktconsolidatie, ruwe olie en goud blijven stabiel</h2><p>Reuters meldde dat op 13 maart wereldwijde aandelenmarkten voornamelijk consolidatie en smalle volatiliteit vertoonden, waarbij de S&amp;P 500-index en NASDAQ-index licht daalden op woensdag, omdat beleggers winst namen in aandelen van chipfabrikanten en wachtten op verdere aanwijzingen over producentenprijsgegevens en inflatietrends voor de volgende week Federal Reserve-vergadering. De halfgeleiderindex (.SOX) is met 2,5% gedaald sinds zijn recente sterke stijging en is dit jaar tot nu toe met 17% gestegen. Het aandeel NVDA.O, gedreven door optimisme over kunstmatige intelligentie, heeft onlangs een stijging gezien in deze sector, maar het aandeel is met 1,1% gedaald.</p>
<p>De iets hogere dan verwachte consumentenprijsgegevens op dinsdag hebben de hoop op renteverlagingen in de komende maanden niet kunnen temperen, en ook de maandelijkse Amerikaanse detailhandelsverkopen zullen op donderdag worden vrijgegeven.</p>
<p>De in februari vrijgegeven Amerikaanse producentenprijsgegevens kunnen donderdag meer inzicht geven in inflatie. Quincy Krosby, Chief Global Strategist bij LPL Financial, zei: ‘De meest recente gegevens benadrukken eigenlijk de toenemende trend van inflatie. Daarom is dit belangrijk’.</p>
<p>De Aziatische markt had op donderdag geen duidelijke richting, hoewel deze in de buurt bleef van een zeven maanden hoogtepunt op donderdag. Terwijl investeerders wachtten op nieuwe prikkels om de wereldwijde renteverlagingcyclus verder te verduidelijken, handelden ze voornamelijk zijwaarts. Investeerders bereiden zich voor op een mogelijk volatiele beleidsvergadering van de Bank of Japan volgende week.</p>
<p>Volgens de CME FedWatch-tool wordt verwacht dat de Federal Reserve de rentetarieven ongewijzigd zal laten tijdens de volgende vergadering volgende week, maar handelaren voorspellen een kans van 65% op de eerste renteverlaging in juni.</p>
<p>Het belangrijkste evenement op de Aziatische economische kalender van donderdag was de publicatie van de gegevens over de groothandelsprijsinflatie in India. De vorige dag toonden de gegevens aan dat hoewel de industriële productie niet aan de verwachtingen voldeed, de jaarlijkse consumenteninflatie in februari iets hoger was dan verwacht.</p>
<p>In China steeg de blue chip Shanghai en Shenzhen 300 Index (.CSI300) met 0,46%, terwijl de Shanghai Composite Index (.SSEC) iets steeg met 0,25%; De Hong Kong Hang Seng Index (.HSI) opende een nieuw tabblad en werd naar beneden getrokken door een daling van 0,9% in technologieaandelen, met een daling van 0,1% (.HSTECH).</p>
<p>Wat betreft grondstoffen steeg Brent ruwe olie met 8 cent naar $84,11 per vat, terwijl Amerikaanse ruwe olie met 7 cent steeg naar $79,79 per vat.</p>
<p>De goudprijs bleef stabiel op $2.174,69 per ounce.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S. &amp; Icing</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Overname van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>