RGFnZWxpamtzIG5pZXV3cyB8IFp1aWQtS29yZWEgdmVyYmllZHQgaWxsZWdhbGUgY3J5cHRvaGFuZGVsOyBKdXN0aW4gU3VuIHN0b3J0IG1lZXIgZGFuIDEwMEsgU1RFVEhzIG9wIEVpZ2VuTGF5ZXI7IEJpdGNvaW4gTDJzIHN0aWpnZW4gbmFhciAyNTsgUlNJQyBJbnNjaHJpanZpbmdzcHJpanplbiBiZXJlaWtlbiBoaXN0b3Jpc2NoIGh

2024-02-08, 03:59

<p><img src="https://gimg2.gateimg.com/image/article/17073646541_5.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20ZuidKorea20verbiedt20illegale20cryptotransacties20Justin20Sun20stort20meer20dan2010000020stETHs20naar20EigenLayer232896"><a name="Crypto Dagelijks Overzicht: Zuid-Korea verbiedt illegale cryptotransacties, Justin Sun stort meer dan 100.000 stETHs naar EigenLayer" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Zuid-Korea verbiedt illegale cryptotransacties, Justin Sun stort meer dan 100.000 stETHs naar EigenLayer</h2><p>Laten we eerst de laatste ontwikkelingen onderzoeken bij regelgevende instanties in verschillende regio’s over de hele wereld.</p>
<p>Volgens het persbureau Yonhap News Agency heeft de Zuid-Koreaanse Financial Commission vandaag aangekondigd dat zij al vóór de implementatie van de Virtual Asset User Protection Act op 19 juli een wettelijke kennisgeving over de wet en de Regelingen inzake het toezicht op de virtuele activabranche hadden uitgegeven op 22 juli.</p>
<p>Volgens de uitvoeringsvoorschriften en regelgevende bepalingen zijn marktmanipulatie, illegale transacties en het gebruik van niet-openbaar belangrijke informatie van virtuele activa voor handel verboden. Degenen die de voorschriften overtreden, kunnen worden veroordeeld tot strafrechtelijke straffen zoals een gevangenisstraf van meer dan een jaar, of een boete van drie tot vijf keer het bedrag van illegale winsten. Als het bedrag van onrechtmatige voordelen meer dan 5 miljard Koreaanse won bedraagt, is de maximale straf levenslange gevangenisstraf. Ook kan een boete van tweemaal het bedrag van onrechtmatige voordelen worden opgelegd.</p>
<p>Onlangs heeft het Amerikaanse ministerie van Financiën het 2024 National Money Laundering, Terrorist Financing, and Spread Financing Risk Assessment Report uitgebracht, waarin staat dat criminelen, fraudeurs en illegale actoren zich steeds vaker wenden tot virtuele activa. De afdeling biedt een gedetailleerde inleiding tot hoe gewetenloze actoren geld witwassen door het continue gebruik van contant geld en cryptocurrency voor fraude, drugshandel, mensenhandel en corruptie. In het witwasrapport staat: “Hoewel witwasactiviteiten die voortvloeien uit drugshandel voornamelijk gebaseerd zijn op contant geld, trekt het gebruik van virtuele activa steeds meer de aandacht van Amerikaanse wetshandhavingsinstanties.” Het Amerikaanse ministerie van Financiën is van plan om in de komende weken een strategisch plan uit te brengen, bedoeld om suggesties te doen om deze problemen aan te pakken.</p>
<p>Bovendien heeft de Hong Kong Securities and Futures Commission recentelijk een waarschuwing afgegeven dat het publiek op zijn hoede moet zijn voor verdachte beleggingsproducten en gerelateerde projecten die te maken hebben met de Hong Kong International Financial Center Token (IFCT). Hoewel de relevante promotiematerialen beweren dat het product officieel is goedgekeurd in Hong Kong, heeft de China Securities Regulatory Commission (CSRC) duidelijk verklaard dat het product niet is goedgekeurd door de CSRC voor verkoop aan het Hong Kongse publiek. De China Securities Regulatory Commission heeft het opgenomen in de lijst met waarschuwingen voor verdachte beleggingsproducten en het publiek gewaarschuwd voor de risico’s van beleggingsproducten die niet worden erkend door de China Securities Regulatory Commission, inclusief het risico om alle investeringen te verliezen.</p>
<p>Volgens DefiLlama-gegevens heeft het liquiditeitsherbeleggingsprotocol EigenLayer TVL de grens van $4,5 miljard overschreden en staat het momenteel op $4,574 miljard, met een groeipercentage van 16,21% in de afgelopen 24 uur en een groeipercentage van 125% in de afgelopen 7 dagen. Eerder werd gemeld dat de toename van TVL werd aangedreven door de tijdelijke annulering van de stakingslimiet van EigenLayer.</p>
<p>Volgens on-chain analist @ai_9684xtpa heeft Justin Sun 109.327 stETHs gedeponeerd in EigenLayer, ter waarde van $259 miljoen. Negen uur geleden ontzegelde Justin Sun alle wstETH in Lido als stETH, transfereerde het naar twee nieuwe adressen en sloeg het op in EigenLayer; Momenteel blijven er slechts 4.393 stETHs over in Prisma Finance voor het adres 0x9FC…c19Fe.</p>
<p>DWG Ventures verklaarde op het X-platform dat ondanks <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> leidend Layer 2 met drie jaar voorsprong met 38 L2’s, het aantal <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L2s zijn in minder dan een jaar gestegen naar 25.</p>
<p>Volgens de samengestelde lijst omvatten deze <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> L2’s BEVM, BiopDAO, Dovi, Elastos, Interlay, Map Protocol, Omni Layer, Rootstock, SatoshiVM, <a href="/price/stacks-stx" rel="nofollow noopener noreferrer" target="_blank">Stacks</a>, U Protocol, b ² Network, Bison Labs, BOB, Botanix Labs, Chainway, Lighting Network, Liquid Network, LumiBit, Merlin Chain, RGB Network, Rolkit, RollUX, ROOS en Rosetta Network.<br>Volgens Bloomberg en gegevens samengesteld door CryptoQuant zijn de mijndepots van Bitcoin (ongeverkochte Bitcoin die in digitale portefeuilles van het bedrijf worden gehouden) met 8400 tokens gedaald naar 1,8 miljoen sinds het begin van 2024. De laatste keer dat dit niveau werd bereikt, was in juni 2021.</p>
<p>Analisten zeggen dat deze daling aangeeft dat miners Bitcoin verkopen. Matthew Sigel, directeur van Digital Asset Research bij VanEck, zei: “Miners zijn begonnen met het verkopen van meer tokens om hun balans te verbeteren en financiering te bieden voor groeiende kapitaaluitgaven om met de moeilijke periode van halvering van blokbeloningen in april om te gaan. Na de halvering wordt schaal nog belangrijker.”</p>
<p>De verkoop door mijnwerkers lijkt druk uit te oefenen op de Bitcoin-prijzen, aangezien de Bitcoin-prijzen worstelen sinds de goedkeuring van de eerste Bitcoin ETF in de Verenigde Staten op 10 januari. Gedurende deze periode daalde de token met ongeveer 6% naar $43.000. Volgens de gegevens van CryptoQuant zijn er sinds de goedkeuring van de ETF 3.617 Bitcoins overgedragen van mijnwerkersportefeuilles naar beurzen. Op 1 februari vond een nettoutstroom van 13.542 Bitcoins plaats, wat de grootste enkele dagelijkse uitstroom sinds december 2020 markeert.</p>
<p>Volgens Deribit-gegevens zullen BTC-opties met een nominale waarde van meer dan $573 miljoen en ETH-optiecontracten met een nominale waarde van $468 miljoen op 9 februari aflopen en worden geleverd. De maximale pijnsprijs voor BTC is $42.000; De maximale pijnsprijs voor ETH is $2.350.</p>
<p>Wat betreft marktfluctuaties, volgens gegevens van Magic Eden, staat de RSIC-inie RSIC METAPROTOCOL vloerprijs momenteel op 0,115 BTC (ongeveer $4.952), wat een nieuwe historische hoogte bereikt met een cumulatieve transactievolume van 509,1 BTC. Er wordt gemeld dat RSIC een peer-to-peer runetoewijzingssysteem is gebaseerd op Bitcoin. De kern ervan is een digitaal spel waarbij spelers runen verkrijgen door RSIC-tokens te beheren en te manipuleren, die op een gegeven moment in de toekomst op het Bitcoin-netwerk zullen worden ‘gegraveerd’.</p>
<p>Volgens Cointelgraph toont de gegevens van CoinLedger, een leverancier van cryptobelastingsoftware, aan dat cryptobeleggers in 2023 een gemiddelde nettowinst van bijna $900 ontvingen bij de verkoop van cryptocurrency. Dit staat in schril contrast met 2022, toen verschillende cryptobedrijven failliet gingen en beleggers miljarden dollars verloren.</p>
<p>CoinLedger analyseerde haar rapport van 500.000 gebruikers en ontdekte dat elke cryptobelegger gemiddeld een gerealiseerd rendement van $887,60 behaalde in 2023. Naarmate de industrie herstelde, verbeterde de situatie. CoinLedger voegde eraan toe: ‘Dit staat in schril contrast met 2022 - in dat jaar behaalden mediane cryptobeleggers een verlies van $7102’.</p>
<h2 id="h2-Macro20Fedfunctionarissen20onderdrukken20gezamenlijk20de20verwachtingen20van20renteverlagingen20met20een20kans20van20minder20dan202020voor20renteverlagingen20in20maart258213"><a name="Macro: Fed-functionarissen onderdrukken gezamenlijk de verwachtingen van renteverlagingen, met een kans van minder dan 20% voor renteverlagingen in maart" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Fed-functionarissen onderdrukken gezamenlijk de verwachtingen van renteverlagingen, met een kans van minder dan 20% voor renteverlagingen in maart</h2><p>Op 7 februari bleef het aantal veilingen van 10-jarige Amerikaanse staatsobligaties onverwacht stabiel, met de opbrengsten van Amerikaanse staatsobligaties die eerst daalden en daarna stegen. De benchmarkopbrengst van Amerikaanse staatsobligaties op 10 jaar daalde kortstondig tot onder de 4,10%, maar keerde snel terug naar 4,10%; De opbrengst van de Amerikaanse staatsobligatie op 2 jaar, die gevoelig is voor rentetarieven, steeg met 4,40% tijdens de handel. De Amerikaanse dollarindex daalde verder van zijn bijna driemaandelijkse hoogtepunt, daalde tijdens de handel onder de 104-markering en sloot uiteindelijk 0,08% lager af op 104,05.</p>
<p>Spotgoud brak door het merkteken van 2040 en zakte terug in de handelssessie, sloot vlak met een lichte daling van 0,04% op $2.035 per ounce; Spotzilver sloot 0,95% lager op $22,22/ounce.</p>
<p>Ruwe olie is drie opeenvolgende dagen gestegen naar een hoogste punt van een week, en de intraday stijging is afgenomen nadat de EIA aankondigde dat de Amerikaanse ruwe olievoorraden vorige week met 5,521 miljoen vaten de verwachtingen overtroffen. WTI ruwe olie sloot 0,82% hoger op $74,01 per vat; Brent ruwe olie sloot 0,85% hoger op $79,32 per vat. De afwikkelingsprijs van Amerikaanse aardgasfutures is voor het eerst sinds maart 2023 onder de $2 gezakt.</p>
<p>De Amerikaanse aandelenmarkt sloot hoger, met de Dow Jones die 0,4% steeg en de S&amp;P 500-index die 0,83% steeg, waardoor een nieuw slotrecord werd bereikt. De Nasdaq steeg met 0,95%.</p>
<p>Op woensdag verklaarden vier functionarissen van de Federal Reserve dat zij van mening zijn dat er momenteel geen dringende situatie is voor renteverlagingen, wat overeenkomt met de opvattingen van andere beleidsmakers in de afgelopen dagen. Zij verklaarden expliciet dat renteverlagingen pas mogelijk zijn vanaf mei op zijn vroegst.</p>
<p>Directeur van de Federal Reserve Kugler, voorzitter van de Boston Fed Collins, voorzitter van de Minneapolis Fed Kashkali en voorzitter van de Richmond Fed Barkin hebben allemaal twijfels over wanneer de Fed kan beginnen met het verlagen van de rente van 20-jarige hoogtepunten, ondanks de aanzienlijke verbeteringen in de inflatie vorig jaar. Deze opmerkingen komen grotendeels overeen met de boodschap die Federal Reserve-voorzitter Powell de afgelopen week heeft overgebracht, waarbij wordt benadrukt dat de Fed pas bereid is de rente te verlagen wanneer zij er vertrouwen in heeft dat de inflatie zich richting het streefpercentage van 2% beweegt, dus de kans op een renteverlaging tijdens de vergadering van 19-20 maart is onwaarschijnlijk.</p>
<p>Beleggers hebben hun inzet op de renteverlaging in maart verminderd en hun aandacht verlegd naar de volgende beslissing van de Federal Reserve op 1 mei, maar geloven dat de kans op vroegtijdige actie nog steeds klein is.</p>
<p>Volgens CME’s Federal Reserve Observation is de kans dat de Federal Reserve de rentetarieven handhaaft in het bereik van 5,25% - 5,50% in maart 81,5%, en de kans op een renteverlaging van 25 basispunten is 18,5%. De kans om de rentetarieven ongewijzigd te handhaven in mei is 36,6%, de kans op een cumulatieve verlaging van 25 basispunten is 53,2%, en de kans op een cumulatieve verlaging van 50 basispunten is 10,2%.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>