RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBlbiBFVEYncyBPc2NpbGxlcmVuLCBBbHRjb2lucyBEdWlrZW47IFNvbGFuYSB0cmVlZHQgb3AgdGVnZW4gVmFsaWRhdG9yIFNhbmR3aWNoIEFhbnZhbGxlbjsgRmlkZWxpdHkgVG9rZW5pc2VlcnQgR2VsZG1hcmt0Zm9uZHNlbiBvcCBKUE1vcmdhbiBDaGFzZSBCbG9ja2NoYWlu

2024-06-11, 03:59

<p><img src="https://gimg2.gateimg.com/image/article/17180851261_7.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20stroomt20220miljard20ETH20Institutioneel20Koopvolume20Hoogste20Sinds20Maart20Solana20treedt20op20tegen20Validator20Sandwich20Aanvallen20Fidelity20tokeniseert20Geldmarktfondsen20op20JP20Morgan20Blockchain907581"><a name="Crypto Dagelijkse Samenvatting: BTC stroomt $2 miljard, ETH Institutioneel Koopvolume Hoogste Sinds Maart; Solana treedt op tegen Validator Sandwich Aanvallen; Fidelity tokeniseert Geldmarktfondsen op JP Morgan Blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC stroomt $2 miljard, ETH Institutioneel Koopvolume Hoogste Sinds Maart; <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> treedt op tegen Validator Sandwich Aanvallen; Fidelity tokeniseert Geldmarktfondsen op JP Morgan Blockchain</h2><p>Laten we eerst de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s, volgens gegevens van Farside Investor, zag de Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) aanhoudende uitstroom van $39,5 miljoen op 10 juni, terwijl de Fidelity Bitcoin Spot ETF (FBTC) uitstroom van $3,0 miljoen zag, de Bitwise Bitcoin Spot ETF (BITB) instroom van $7,6 miljoen zag, en de Invesco Galaxy Bitcoin ETF (BITB) instroom van $7,6 miljoen zag. (BITB) instroom van $7,6 miljoen en Invesco Galaxy Bitcoin Spot ETF (BTCO) uitstroom van $20,5 miljoen.</p>
<p>Vermogensbeheerder CoinShares zei in een rapport op maandag dat cryptoinvesteringsproducten vorige week bijna $2 miljard aan instroom aantrokken, waardoor de cryptoinvesteringsmarkt voor de vijfde opeenvolgende week hoger werd gedreven. De totale instroom was meer dan $4,3 miljard.</p>
<h3 id="h3-Solana20pakt20Validator20Sandwichaanvallen20aan201938"><a name="Solana pakt Validator Sandwich-aanvallen aan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Solana pakt Validator Sandwich-aanvallen aan</h3><p>Een groep van <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Verifiers van (SOL) worden geconfronteerd met financiële straffen omdat ze naar verluidt financiële aanvallen tegen cryptocurrency-handelaren faciliteren. Bronnen zeiden dat meer dan 30 validators afgelopen weekend uit het delegatieprogramma van de Solana Foundation zijn verwijderd. Hoewel ze nog steeds verifiers zijn op het netwerk, komen ze niet langer in aanmerking voor beloningen voor het verifiëren van Solana blockchain-transacties.</p>
<p>Bij sandwichaanvallen plaatst men een bestelling vóór een transactie en direct daarna nog een bestelling. Aanvallers zullen de eerste in behandeling zijnde transactie tussen gelijktijdige front-end en back-end transacties plaatsen om de prijs van het activum te manipuleren en te profiteren van het verschil. Tim Garcia, hoofd van verifier-relaties bij Solana, kondigde op Discord aan dat hij verificatoren zou verwijderen en verklaarde dat ‘deelname aan een privégeheugenpool om sandwichaanvalstransacties uit te voeren of anderszins de integriteit van Solana-gebruikers in gevaar te brengen niet zal worden toegewezen.’</p>
<p>Een bericht van de Jito Foundation-governance dat op zondag werd gepubliceerd, onthulde dat 10% van de JitoSOL-pool wordt gedelegeerd aan validators die private geheugenpools uitvoeren. De Jito Foundation stelt voor om deze validators verder te bestraffen door meer ingezette SOL’s te beperken.</p>
<h3 id="h3-Fidelity20Tokenizes20Geldmarktfondsen20op20JP20Morgan20Blockchain943768"><a name="Fidelity Tokenizes Geldmarktfondsen op JP Morgan Blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Fidelity Tokenizes Geldmarktfondsen op JP Morgan Blockchain</h3><p>De Britse fondsbeheerder Fidelity International is toegetreden tot het Tokenized Collateral Network (TCN) van JPMorgan en heeft een partnerschap aangegaan met Onyx Digital Assets om de tokenisatie van zijn geldmarkt fondsen (MMFs) te testen. De verbinding tussen de transferagent van het fonds en het Tokenized Collateral Network maakte bijna onmiddellijke tokenisatie mogelijk.</p>
<p>Tokenisatie verwijst naar de creatie van een virtueel beleggingsvoertuig op de blockchain dat echte wereld activa vertegenwoordigt zoals onroerend goed, edelmetalen en verzamelobjecten. Het is ook van toepassing op aandelen en obligaties. Tokenisatie van traditionele financiële activa is een topprioriteit geworden voor banken, en JP Morgan werkt hier al jaren aan.</p>
<p>Fidelity International heeft een lange geschiedenis in de digitale activaruimte, en heeft onlangs in maart samengewerkt met de Zwitserse bank Sygnum aan een tokenisatieproject. In oktober vorig jaar heeft JPMorgan Chase de eerste realtime blockchain-gebaseerde transactie voor onderpandafwikkeling uitgevoerd, waarbij getokeniseerde aandelen van het BlackRock Money Market Fund betrokken waren. Deze aandelen werden overgedragen aan Barclays als onderpand voor een OTC-derivatenhandel. BlackRock heeft tokenisatie omarmd via zijn publieke BUIDL-project met het tokenisatieservicesbedrijf Securitize.</p>
<p>Stephen Whyman, Hoofd Debt Capital Markets bij Fidelity International, zei in een e-mailinterview: “Het tokeniseren van onze geldmarkt fondsaandelen als onderpand is een belangrijke en natuurlijke eerste stap in het uitbreiden van onze adoptie van deze technologie. De voordelen voor onze klanten en het bredere financiële systeem zijn duidelijk; met name verhoogde efficiëntie bij het voldoen aan margin requirements en verminderde transactiekosten en operationeel risico.”</p>
<h2 id="h2-Markttrends20BTC20oscilleert20op20hoog20niveau20terwijl20Altcoins20over20het20algemeen20dalen88502"><a name="Markttrends: BTC oscilleert op hoog niveau terwijl Altcoins over het algemeen dalen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC oscilleert op hoog niveau terwijl Altcoins over het algemeen dalen</h2><p><strong>BTC</strong>: Na vanochtend vroeg boven de $70.000 te zijn gestegen, was er een terugval en consolideert het nu rond de $69.400. Op korte termijn zal het waarschijnlijk schommelen in het bereik van $68.000-$70.000, in afwachting van de CPI-gegevens van deze week om een nieuwe marktbeweging te kiezen.</p>
<p><strong>ETH</strong>: Momenteel schommelt het rond de $3.660 met een relatief stabiele trend. Het zal waarschijnlijk op korte termijn schommelen in het bereik van $3.600-3.700.</p>
<p><strong>Altcoins</strong> Over het algemeen is de marktsentiment relatief koud. Investeerders moeten zorgvuldig kiezen en letten op markthotspots en individuele sterke munten.</p>
<h3 id="h3-Macroeconomie104188"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p><strong>Amerikaanse aandelen hoger</strong>: Beleggers wachten op de publicatie van CPI-gegevens op woensdag, die naar verwachting een grote invloed zullen hebben op de markt.</p>
<p><strong>CPI-gegevens</strong>: CPI-gegevens zijn belangrijke economische indicatoren die de verwachtingen van de markt ten aanzien van inflatie en monetair beleid kunnen beïnvloeden, en daarmee de trend van de cryptomarkt kunnen beïnvloeden.</p>
<h3 id="h3-Markt20Hotspots606831"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>MOEDER</strong>: Deze munt steeg vandaag met 20% toen Iggy aankondigde dat MOTHER in de toekomst kan worden gebruikt om telefoonrekeningen te betalen, wat de toepassingsscenario’s vergroot en de aandacht van de markt trekt.</p>
<p><strong>BRETT</strong>: Meme coin op Base chain, marktkapitalisatie overschreed $1,6 miljard, sterke prestaties.</p>
<p><strong>BZZ</strong>: Een van de toonaangevende tokens in de opslagsector van de laatste bullmarkt, met intraday winsten van meer dan 50%. Met een huidige circulerende marktkapitalisatie van $32 miljoen en een marktkapitalisatierangschikking van 950, toont het een sterke opwaartse momentum.</p>
<h3 id="h3-Token20ontgrendeld223606"><a name="Token ontgrendeld:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Token ontgrendeld:</h3><p><strong>STRK</strong>: Het Ethernet Layer2-netwerktoken zal deze week $80 miljoen aan tokens ontgrendelen. Het ontgrendelen van een grote hoeveelheid tokens kan leiden tot marktvolatiliteit, en investeerders moeten goed letten op de marktbewegingen voor en na de ontgrendeling.</p>
<h3 id="h3-Waarschuwing20voor20risicos29027"><a name="Waarschuwing voor risico’s:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waarschuwing voor risico’s:</h3><p>De cryptomarkt is volatiel, investeerders moeten voorzichtig zijn en vermijden om hoogtepunten na te jagen.<br>Let goed op macro-economische gegevens, zoals CPI-gegevens, die mogelijk meer invloed hebben op de markt.<br>Let op veranderingen in het marktsentiment en pas investeringsstrategieën tijdig aan.</p>
<h2 id="h2-Macro20SampP2050020en20Nasdaq20bereiken20nieuwe20slotrecords20Fedvergadering20en20CPI20komen20eraan766732"><a name="Macro: S&amp;P 500 en Nasdaq bereiken nieuwe slotrecords; Fed-vergadering en CPI komen eraan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: S&amp;P 500 en Nasdaq bereiken nieuwe slotrecords; Fed-vergadering en CPI komen eraan</h2><p>Op maandag 10 juni meldde Reuters dat de S&amp;P 500 en de Nasdaq nog steeds nieuwe slotrecords bereikten, ondanks de voorzichtigheid van beleggers voorafgaand aan het aanstaande Consumer Price Index (CPI) rapport van deze week en de beleidsverklaring van de Federal Reserve.</p>
<p>Met betrekking tot specifieke indices steeg de Dow Jones met 0,2 procent, steeg de S&amp;P 500-index met 0,3 procent en steeg de Nasdaq met 0,4 procent.</p>
<p>Nvidia, dat de Nasdaq en S&amp;P 500 omhoog dreef, sloot 0,7 procent hoger na een aandelensplitsing van tien aandelen. Sommige investeerders geloven dat de chipfabrikant waarschijnlijk zal worden opgenomen in de Dow Jones blue chips.</p>
<p>Het rapport over de consumentenprijsindex van mei wordt op woensdag vrijgegeven wanneer de tweedaagse beleidsvergadering van de Federal Reserve eindigt. De Fed zal zijn nieuwste economische en beleidsprojecties vrijgeven en naar verwachting de rentetarieven ongewijzigd laten. Beleggers zullen letten op aanwijzingen wanneer de Fed zal beginnen met het verlagen van de rente.</p>
<p>Op dinsdag 11 juni lijken de Aziatische markten beperkt te worden door stijgende obligatierendementen, politieke onrust in Europa, een sterkere Amerikaanse dollar en voorzichtigheid voorafgaand aan het rentebesluit van de Federal Reserve later in de week.</p>
<p>Desalniettemin is de Japanse economie de week sterk begonnen, mede dankzij hoger dan verwachte herzieningen van het bruto binnenlands product in het eerste kwartaal en een algehele daling van de yen voor de rendementen op Japanse staatsobligaties.</p>
<p>De economische gegevens van dinsdag bestaan voornamelijk uit Zuid-Koreaanse lopende rekeninggegevens, Filipijnse handelsgegevens en Australische zakelijke vertrouwensgegevens.</p>
<p>Op maandag heeft Japan’s herziene BBP-gegevens het marktvertrouwen in de Japanse economie vergroot en de verwachtingen verhoogd dat de Bank of Japan zal doorgaan met beleidsnormalisatie tijdens de beleidsvergadering later in de week. De 10-jarige Japanse overheidsobligatierente steeg maandag met 4,5 basispunten, de grootste stijging in twee maanden en genoeg om de helft van de daling van vorige week om te keren.</p>
<p>Record sluitingshoogtes op Wall Street en sterke Amerikaanse staatsobligatierendementen zouden de Amerikaanse dollar blijven ondersteunen, maar deze combinatie kan meer druk uitoefenen op opkomende marktactiva.</p>
<p>Op vrijdag daalde de CSI 300 blue-chip index en de Shanghai Composite Index naar hun laagste punten in zes weken. Met Chinese aandelen gesloten op maandag, zou de opening van dinsdag scherpe volatiliteit kunnen zien als investeerders winsten inhalen over twee wereldwijde handelsdagen.</p>
<p>Wat betreft grondstoffen stegen de olieprijzen op dinsdag, waarmee de winst van de vorige dag werd verlengd, vanwege de verwachting van een verhoogde vraag naar brandstof in het seizoen en de mogelijkheid dat de VS ruwe olie koopt om zijn oliereserves aan te vullen. De winsten werden beperkt door een sterkere dollar. Brent ruwe olie futures stegen met 28 cent naar $81,91 per vat, terwijl West-Texas Intermediate ruwe olie futures stegen met 31 cent naar $78,05 per vat.</p>
<p>De olieprijzen stegen ongeveer 3 procent naar een hoogste niveau in een week op maandag, gedreven door de verwachting van een hogere vraag naar brandstof deze zomer, ondanks een sterkere dollar op basis van de verwachting dat de Federal Reserve de rentetarieven hoger zal houden.</p>
<p>Goud stond net boven een maand laag op $2.306 per ounce.</p>
<div class="blog-details-info"><br><div>Auteur: <strong> Sherry S. &amp; Icing. </strong>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen 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 zal juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div>