RGFnZWxpamtzIG5pZXV3cyB8IERlemUgd2VlayB6YWwgZGUgcHVibGljYXRpZSB2YW4gZGUgQW1lcmlrYWFuc2UgY29uc3VtZW50ZW5wcmlqc2luZGV4IChDUEkpIGVuIGRlIEZlZGVyYWwgUmVzZXJ2ZSBGT01DLXJlc29sdXRpZXMgcGxhYXRzdmluZGVuOyBUb2tlbnMgdGVyIHdhYXJkZSB2YW4gbWVlciBkYW4gJDI0MCBtaWxqb2VuIHd

2024-06-10, 05:01

<p><img src="https://gimg2.gateimg.com/image/article/17179986491_6-06.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Deze20week20zal20de20publicatie20van20de20US20Consumer20Price20Index20CPI20en20de20Federal20Reserve20FOMCresoluties20zien20Tokens20ter20waarde20van20meer20dan2024020miljoen20worden20ontgrendeld20Voormalig20president20Trump20zal20een20rondetafelgesprek20organiseren20gericht20op20de20Amerikaanse20Bitcoin20mining746872"><a name="Crypto Daily Digest: Deze week zal de publicatie van de U.S. Consumer Price Index (CPI) en de Federal Reserve FOMC-resoluties zien; Tokens ter waarde van meer dan $240 miljoen worden ontgrendeld; Voormalig president Trump zal een rondetafelgesprek organiseren gericht op de Amerikaanse Bitcoin mining." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Deze week zal de publicatie van de U.S. Consumer Price Index (CPI) en de Federal Reserve FOMC-resoluties zien; Tokens ter waarde van meer dan $240 miljoen worden ontgrendeld; Voormalig president Trump zal een rondetafelgesprek organiseren gericht op de Amerikaanse <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> mining.</h2><p>Volgens gegevens van Token Unlocks zullen meerdere projecten deze week een eenmalige grootschalige ontgrendeling van tokens uitvoeren. Daaronder: <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> zal op 12 juni 11,31 miljoen APT ontgrendelen, ter waarde van ongeveer US$96,7 miljoen, wat overeenkomt met 2,58% van de omloopvoorraad; Immutable zal op 14 juni 25,53 miljoen IMX ontgrendelen, ter waarde van ongeveer US$51,32 miljoen, wat overeenkomt met 1,72% van de omloopvoorraad; Starknet zal op 15 juni 64 miljoen STRK ontgrendelen, ter waarde van ongeveer US$74,88 miljoen, wat overeenkomt met 4,92% van de omloopvoorraad.</p>
<p>Bovendien toont Dune-gegevens aan dat het totale bedrag aan gestaked <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> op de beacon chain staat 32.912.765 ETH, met 1.028.524 validators. De ingezette ETH vertegenwoordigt 27,46% van het totale ETH-aanbod. Opmerkelijk is dat het liquiditeits-stakingprotocol Lido een aandeel van 28,86% van de ingezette ETH heeft.</p>
<p>LayerZero CEO reageerde op het probleem van het gemelde Sybil-adres dat smeergeld betaalt aan de verslaggever en adviseerde ten zeerste tegen eventuele wijzigingen in het rapport. Hij benadrukte dat het team de oorspronkelijke gegevens van GitHub en Commonwealth heeft en dat het wijzigen of verwijderen van informatie over de Sybil-cluster het hele beloningsprogramma in gevaar zou kunnen brengen. Hij kondigde ook aan dat de definitieve lijst van Sybil-adressen eind juni zal worden vrijgegeven.</p>
<p>Volgens de officiële website van UXLINK en het officiële X-platform heeft het aantal geregistreerde gebruikers van UXLINK de 10 miljoen overschreden. DappRadar-gegevens tonen aan dat het aantal maandelijkse actieve onafhankelijke adressen op de UXLINK-keten 4,7 miljoen heeft bereikt, wat de eerste plaats inneemt in het hele domein.</p>
<p>Volgens nieuws. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> In de afgelopen 90 dagen is de stablecoin-economie met meer dan 11% gegroeid, met een instroom van $16,23 miljard in de cryptomarkt, waarvan USDT goed is voor meer dan 69%. In de afgelopen maand is het aanbod van USDT met 1,3% gestegen. Ondertussen heeft Circle’s <a href="/price/usd-coin-usdc" rel="nofollow noopener noreferrer" target="_blank">USD Coin</a>(USDC) is in de afgelopen maand met 2,7% gedaald, maar heeft in de afgelopen 90 dagen groei laten zien, waarbij de marktkapitalisatie is gestegen van $29,88 miljard op 11 maart tot $32,23 miljard vandaag.</p>
<p>De eerste fase van beloningen voor de migratie van het AI-ecosysteemproject NetX is begonnen met de distributie. Alle gebruikers die $TRIAS-tokens naar het NetX-netwerk migreren, komen in aanmerking om $TAS-beloningen te ontvangen. De eerste fase van de NetX-migratie zal eind juni worden afgerond.</p>
<p>Triathon, een Web3+AI-modeltrainingsproject, heeft officieel zijn bestuursvoorstelfunctie gelanceerd, waarbij de $GROW-bestuurstoken het middelpunt wordt. Daarnaast heeft Triathon de integratie van het AIA-trainingsmodel en het NetX-mainnet aangekondigd. Deze stappen hebben als doel een robuustere <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> AI-trainings-ecosysteem op te bouwen.</p>
<p>io.net oprichter en CEO Ahmad Shadid heeft zijn ontslag als CEO aangekondigd. Naast zijn vertrek zal hij 1 miljoen IO tokens doneren aan de io.net Internet of GPUs Foundation.</p>
<p>Volgens de gegevens van DefiLlama heeft pump.fun in de afgelopen 24 uur $1.15 miljoen verdiend, wat het op twee na hoogste dagelijkse inkomen in zijn geschiedenis markeert. Het vorige record voor dagelijkse inkomsten was $1.48 miljoen, vastgesteld op 30 mei.</p>
<p>Trump haalde $12 miljoen op tijdens een evenement georganiseerd door tech-venture capitalists in San Francisco. Daarnaast kondigde zijn cryptocurrency-adviseur, David Bailey, aan dat Trump een rondetafelgesprek zou houden over Bitcoin-mining in de Verenigde Staten. Hoewel Bailey niet bekendmaakte welke bedrijven of individuele mijnwerkers het toekomstige evenement zouden bijwonen, verduidelijkte hij later in een volgende post op X dat erkende spelers uit de industrie zouden deelnemen aan de conferentie.</p>
<p>Volgens Lookonchain monitoring hebben negen Bitcoin ETF’s hun bezit van 3.689 BTC (ongeveer $261,9 miljoen) op vrijdag verhoogd.</p>
<p>De gegevens van de Amerikaanse non-farm payrolls voor mei toonden een stijging, samen met een stijging van de werkloosheid. Als gevolg hiervan hebben handelaren in Amerikaanse rentefutures hun weddenschappen op een renteverlaging door de Federal Reserve in september sterk verminderd. Ze zien nu een kans van 55% op een renteverlaging, vergeleken met 70% in eerdere gegevens.</p>
<h2 id="h2-Marktanalyse20BTC20strijdt20consequent20om20de207000020grens20terwijl20de20altcoin20sector20een20snelle20opleving20doormaakt380671"><a name="Marktanalyse: BTC strijdt consequent om de $70.000 grens, terwijl de altcoin sector een snelle opleving doormaakt." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktanalyse: BTC strijdt consequent om de $70.000 grens, terwijl de altcoin sector een snelle opleving doormaakt.</h2><p><strong>Algemene trend:</strong><br>Bitcoin (BTC) heeft de laatste tijd op hoge niveaus geschommeld, waarbij stieren en beren strijden rond de $70.000. Als de prijs vandaag stijgt en blijft sluiten boven de $70.000, kan dit resulteren in een dagelijks voortschrijdend gemiddelde lang arrangement, wat mogelijk een bullish sentiment op de markt kan veroorzaken.</p>
<p>Het is vermeldenswaard dat de Amerikaanse niet-agrarische loongegevens die afgelopen vrijdag zijn vrijgegeven, de verwachtingen ver overtroffen, waardoor de markt de verwachtingen voor een renteverlaging in september verder heeft verlaagd. Als gevolg van dit negatieve nieuws daalden activa zoals Bitcoin, waarbij de prijs daalde tot ongeveer $ 68.400. Op de 4-uurs grafiek begon Bitcoin te herstellen nadat het steun vond bij het 60-perioden voortschrijdend gemiddelde.</p>
<p>Op het gebied van kapitaal <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a>, Amerikaanse spot-ETF’s hebben gedurende 19 opeenvolgende handelsdagen nettostromen laten zien, inclusief een toename van 3.689 BTC (ongeveer $261,9 miljoen) afgelopen vrijdag. Hoewel de marktkapitalisatie van Hong Kongse spot-ETF’s veel kleiner is in vergelijking met de Amerikaanse markt, hebben ze over het algemeen ook nettostromen vertoond.</p>
<p>Samenvattend zijn er vanuit zowel een macro- als microniveau geen tekenen die erop wijzen dat Bitcoin een scherpe daling zal meemaken. Op korte termijn kan het in een consolidatietoestand blijven, terwijl het langetermijnmarktperspectief veelbelovend blijft.</p>
<p><strong>Markt hot spots:</strong><br><strong>RWA-sector: </strong>De sector van reële wereld activa (RWA) is in de afgelopen 24 uur met 7,15% gestegen, met leidende stijgers zoals MKR, ONDO, PENDLE en POLYX. De RWA-sector is het meest nauw gerelateerd aan fysieke toepassingen in deze bullmarkt-cyclus. Het speelt een cruciale rol bij het verhogen van de adoptiesnelheid van encryptietechnologie en -producten en trekt aanzienlijke aandacht van traditionele marktbeleggers.</p>
<p><strong>SocialFi-sector:</strong> Onlangs is het TON Chain-spel Notcoin (NOT), ondersteund door Telegram, in een week tijd vijfvoudig gestegen, wat een gekte in het sociale veld heeft veroorzaakt. De sector is in de afgelopen 24 uur met 2,79% gestegen. Onder de belangrijkste stijgers bevinden zich MOON, CHZ, MASK en CBK, met respectievelijke stijgingen van 7,94%, 7,33%, 4,8% en 3,46%.</p>
<p><strong>GameFi sector: </strong>De blockchain gaming (GameFi) sector, die vorige week de markt leidde, heeft onlangs een afname in populariteit gezien, met een bescheiden stijging van 1,65% in de afgelopen 24 uur. De sector is ook gesteund door overloopfondsen van de populaire click-to-play game Notcoin (NOT). Tokens zoals IMX, PORTAL, BEAM en YGG, die vorige week de daling van BTC volgden, zijn nu begonnen met herstellen.</p>
<p><strong>MEME-sector:</strong> De MEME-sector heeft bewezen een van de meest duurzame tracks te zijn in deze bull run. Van een reeks MEME’s met katten-thema tot gezamenlijke betalings-MEME’s en recente beroemdhedenmunten zoals MOTHET en JENNER, heeft de MEME-sector consistent marktaandacht getrokken door middel van innovatieve distributiemechanismen, marketingstrategieën en verhalende thema’s. De sector is in de afgelopen 24 uur met 0,55% gestegen. Hoewel de prestaties van tokens binnen de sector sterk variëren, hebben sommige, zoals RNT, GME, BRETT, MAGA en MOTHER, relatief hoge stijgingen doorgemaakt.</p>
<p>Samenvattend staat de cryptomarkt voor verdere uitdagingen van macro liquiditeitstekort. Bitcoin blijft schommelen rond de hoge prijsmarkering, terwijl sectoren zoals RWA, SocialFi en GameFi beginnen te herstellen, hoewel de sterkte van dit herstel onzeker blijft. Het is voorzienbaar dat de AI- en MEME-sectoren, ondanks lichte zwakte de afgelopen dagen, nog steeds aanzienlijke aandacht verdienen. Gezien de huidige krappe macro-omgeving moeten beleggers echter voorzichtiger zijn met kapitaalspeculatie. De populariteit van bepaalde sectoren kan snel stijgen en dalen, dus het is cruciaal om waakzaam te blijven. En investeerders wordt geadviseerd om nauwlettend te letten op investeringsmogelijkheden in tokens uit recente hot sectoren, specifiek AI+DePIN en AI+MEME.</p>
<h2 id="h2-Macro20Fed20toont20een20sterker20dan20verwachte20toewijding20aan20het20aanscherpen20van20het20beleid20De20markt20volgt20deze20week20nauwlettend20de20rentebeslissing698154"><a name="Macro: Fed toont een sterker dan verwachte toewijding aan het aanscherpen van het beleid. De markt volgt deze week nauwlettend de rentebeslissing." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Fed toont een sterker dan verwachte toewijding aan het aanscherpen van het beleid. De markt volgt deze week nauwlettend de rentebeslissing.</h2><p>Op dit moment houdt de Federal Reserve zich bezig met de situatie van het aanscherpen van het rentebeleid. Na de bekendmaking van beter dan verwachte werkgelegenheidscijfers afgelopen vrijdag, is de kans op verlaging van de rente door de Federal Reserve opnieuw afgenomen.</p>
<p>Vanwege de sterke prestaties van de arbeidsmarkt, met name de opleving van de loongroei, wordt verwacht dat de inflatie langzamer zal afnemen. Dit maakt het waarschijnlijk dat de Federal Reserve inflatiebestrijding boven de arbeidsmarktvoorwaarden zal stellen bij het nemen van beleidsbeslissingen. Als de inflatiegegevens van mei sterk blijven, zullen de kansen op de implementatie van één of zelfs geen renteverlagingen door de Fed dit jaar aanzienlijk toenemen.</p>
<p>De markt zal deze week nauwlettend toezien op de rentebeslissing van de Federal Reserve. De Fed zal van 12-13 juni een tweedaagse beleidsvergadering houden, waarbij zij een samenvatting van economische projecties en een bijgewerkte dot plot van de rente zal bekendmaken. Deze publicaties zullen het middelpunt van de marktaandacht zijn.</p>
<p>Afgaande op verschillende interpretaties lijkt de Fed een sterkere toewijding te tonen aan haar huidige beleid in vergelijking met voorgaande periodes. Dit is grotendeels te wijten aan een robuuste gegevensprestatie, wat aangeeft dat de Fed een langere observatieperiode nodig heeft om de economische omstandigheden te beoordelen. Bijgevolg verwacht de markt dat de Federal Reserve dit jaar slechts een beperkt aantal renteverlagingen zal doorvoeren, of mogelijk helemaal geen.</p>
<p>Het is echter vermeldenswaard dat hoewel de gegevens van de non-farm payroll die vorige week zijn vrijgegeven de verwachtingen overtroffen, de werkloosheid ook toenam. Het in balans brengen van de noodzaak om de inflatie effectief te onderdrukken zonder de economie te veel af te koelen, kan een belangrijke zorg worden voor de Federal Reserve. Deze situatie verklaart waarom verschillende risico-activa, waaronder Bitcoin, dalingen hebben ervaren, zij het relatief kleine.</p>
<p>Over het algemeen moet de Federal Reserve bij het omgaan met de huidige situatie van een strakker monetair beleid rekening houden met twee belangrijke factoren: werkgelegenheid en inflatie. Na de publicatie van nieuwe gegevens en de komende vergadering van het Federal Reserve-beleidscomité zal de markt een duidelijker inzicht krijgen in de monetaire beleidsrichting van de Fed. We zullen deze ontwikkelingen nauwlettend volgen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong><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 opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>