RGFnZWxpamtzIG5pZXV3cyB8IEFhbmRlbGVua29lcnMgdmFuIEJUQy1taW5lcnMgc3RlZWcgbWV0IDEwJSBkb29yIGRlIHN0ZXVuIHZhbiBUcnVtcDsgTGF5ZXIzIGtvbmRpZ3QgZGUgZmluYW5jaWVyaW5nIHZhbiAkMTVNIGFhbiBpbiBBLXJvbmRlIGZpbmFuY2llcmluZzsgVGVycmFmb3JtIG1vZXQgZWVuIGJvZXRlIHZhbiAkNC40N0I

<p><img src="https://gimg2.gateimg.com/image/article/17182491481_9.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Na20de20belofte20van20Trump20om20Amerikaanse20mijnwerkers20te20ondersteunen20steeg20de20aandelenkoers20van20Bitcoin20mijnwerkers20met201020Layer320kondigde20aan20dat20ze201520miljoen20hebben20opgehaald20in20Series20Afinanciering20vr20de20token20release20en20airdrop20Terraform20heeft20ingestemd20met20het20betalen20van2044720miljard20aan20voorgesteld20vonnis20aan20de20SEC791086"><a name="Crypto Daily Digest: Na de belofte van Trump om Amerikaanse mijnwerkers te ondersteunen, steeg de aandelenkoers van Bitcoin mijnwerkers met 10%; Layer3 kondigde aan dat ze $15 miljoen hebben opgehaald in Series A-financiering vóór de token release en airdrop; Terraform heeft ingestemd met het betalen van $4,47 miljard aan voorgesteld vonnis aan de SEC." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Na de belofte van Trump om Amerikaanse mijnwerkers te ondersteunen, steeg de aandelenkoers van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> mijnwerkers met 10%; Layer3 kondigde aan dat ze $15 miljoen hebben opgehaald in Series A-financiering vóór de token release en airdrop; Terraform heeft ingestemd met het betalen van $4,47 miljard aan voorgesteld vonnis aan de SEC.</h2><p>Laten we eerst de handelsactiviteit van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor ontvingen Fidelity Bitcoin spot ETF’s (FBTC) op 12 juni een instroom van $50,6 miljoen, Bitwise Bitcoin spot ETF’s (BITB) ontvingen een instroom van $14,5 miljoen en ARK 21 Shares Bitcoin spot ETF’s (ARKB) ontvingen een instroom van $8,5 miljoen.</p>
<p><strong>De aandelenkoers van Bitcoin miners steeg met 10% nadat Trump beloofde Amerikaanse miners te ondersteunen</strong><br>Op woensdag, de tweede dag nadat de Amerikaanse presidentskandidaat Donald Trump beloofde de Amerikaanse mijnbouwoperaties te versterken, stegen de Bitcoin-mijnbouwaandelen scherp.</p>
<p>Trump verklaarde in een bericht van 12 juni dat hij hoopt dat ‘alle Bitcoin in de Verenigde Staten zal worden geproduceerd!!!’ en dat dit zal helpen om de Verenigde Staten de energie sector te domineren. Trump zei dat deze verklaring werd afgelegd na een ontmoeting met enkele leidinggevenden uit de industrie.</p>
<p>Volgens berichten heeft Trump deze leidinggevenden ook beloofd dat hij de sector volledig zal steunen als hij in november tot president wordt gekozen. Volgens gegevens van Google Finance behoren TeraWulf (WULF) en Hut 8 Mining (HUT) tot de top tien Bitcoin miners met de grootste stijging in marktwaarde, respectievelijk met 10,5% en 10,07% op 12 juni. Core Scientific (CORZ), Iris Energy (IREN) en Cipher Mining (CIFR) stegen respectievelijk met 9,87%, 9,72% en 8,94%.</p>
<p>Op 11 juni besprak Trump met verschillende bedrijfsleiders in Haihu Manor hoe Bitcoin-mining het elektriciteitsnet kan versterken en meer werkgelegenheid kan creëren. De deelnemende bedrijfsleiders gaven aan dat de ervaring van de avond zeer positief was.</p>
<p><strong>Layer3 kondigde een financiering van $15 miljoen aan in A-ronde financiering voorafgaand aan de token uitgave en airdrop</strong><br>Het token distributieprotocol Layer3 staat op het punt om tokenuitgifte en airdrops te ondergaan. Op woensdag kondigde Layer3 aan dat het succesvol $15 miljoen heeft opgehaald in een A-ronde financiering. Het bedrijf haalde ook $2,5 miljoen op in 2021, en de eerder niet bekendgemaakte $3,7 miljoen strategische financiering werd in 2022 opgehaald door bedrijven zoals Electric en ParaFi. De A-ronde financiering bracht het totale financieringsbedrag van Layer3 op $21,2 miljoen.</p>
<p>Op woensdag verklaarde Layer3 dat deze financieringsronde wordt geleid door ParaFi en Greenfield Capital, met deelname van bedrijven zoals Electric Capital, Immune, Lattice, Tioga, LeadBlock en Amber. De medeoprichters van Layer3 verklaarden dat het project in april begon met het inzamelen van fondsen voor deze financieringsronde en eindigde in mei. Deze financieringsronde maakt gebruik van een structuur van eigen vermogen en token-opties, maar de waardering moet nog worden bekendgemaakt.</p>
<p>Layer3 is een token distributie protocol dat projecten in staat stelt om tokens te distribueren om gebruikers aan te trekken en te behouden. Het verenigt gebruikersactiviteiten tussen meerdere blockchains en applicaties, waardoor de protocollen de tokens effectiever kunnen toewijzen.</p>
<p>Layer3 kondigde A-ronde financiering aan, samenvallend met de lancering en luchtdrop van zijn eigen token L3 deze zomer. Vorige maand lanceerde Layer3 de governance- en utilitytoken L3, met een totale voorraad van 300 miljoen. De initiële luchtdrop zal 5% van de totale voorraad, of 15 miljoen tokens, verdelen onder vroege adoptanten en CUBE-minters. Kumar verklaarde dat CUBE een ‘dynamische NFT’ is die wordt gemunt na het voltooien van de taak.</p>
<p>De airdrop-snapshot is genomen op 10 mei. Layer3 heeft 51% van de totale voorraad toegewezen aan de gemeenschap, terwijl gedetailleerde informatie over de resterende toewijzingen nog moet worden bekendgemaakt.</p>
<p>Layer3 is nog steeds bezig met de ontwikkeling van een nieuw AI-protocol om token distributiestrategieën te optimaliseren, dat naar verwachting later dit jaar zal worden gelanceerd. Kumar verklaarde dat het AI-protocol nieuwe mogelijkheden zal bieden voor projectuitgifte en distributie van tokens, en Layer3 persoonlijker zal maken om tegemoet te komen aan eindgebruikers.</p>
<p><strong>Terraform heeft ingestemd met het betalen van $4,47 miljard aan voorgesteld vonnis aan de SEC</strong><br>De Amerikaanse Securities and Exchange Commission (SEC) heeft op woensdag een voorgestelde definitieve goedkeuringsuitspraak ingediend en heeft rechter Jed Rakov van de Southern District Court of New York verzocht het Terraform-plan goed te keuren.</p>
<p>In februari 2023 diende de SEC aanklachten in tegen Terraform en Do Kwon over de algoritmische stablecoin <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> USD (USD) die een jaar geleden was ingestort, bewerend dat ze investeerders hadden bedrogen en misleid. De twee partijen discussieerden eindeloos over de hoogte van de compensatie. Volgens het huidige voorgestelde vonnis zal Terraform $3,58 miljard aan onrechtmatige winsten betalen en $420 miljoen aan civiele boetes, waarbij Do Kwon wordt verboden om een leidinggevende of directeur te worden van een beursgenoteerd bedrijf.</p>
<p>De SEC geloofde eerder dat Do Kwon ongeveer $204 miljoen zou moeten betalen aan de Terraform faillissement boedel om te verdelen onder beschadigde investeerders.</p>
<h2 id="h2-Markttrends255817"><a name="Markttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends</h2><p>BTC herstelde zich bijna tot $70.000 na de publicatie van CPI-gegevens, maar daalde onder de $68.000 na een toespraak van Fed-voorzitter Powell. Dit toont de hoge gevoeligheid van de markt voor macro-economische gegevens en beleidswijzigingen.</p>
<p>ETH zakte ook terug naar ongeveer $3.550 na een aanzienlijke opleving.</p>
<p>Altcoins: Ondanks de scherpe daling van BTC en ETH in de vroege ochtend, bleven Altcoins nog steeds aanzienlijk stijgen, wat erop kan wijzen dat investeerders op zoek zijn naar andere investeringsmogelijkheden met een hoog risico en hoog rendement.</p>
<h3 id="h3-Macroeconomie304059"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>Aandelen van de VS stegen: Aandelen van de VS blijven historische hoogtepunten bereiken, wat de investeerders weerspiegelt. <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over de toekomstige economische vooruitzichten.</p>
<p>CPI-gegevens: de CPI-gegevens zijn gedaald naar een laagste punt van 3 jaar, wat een toename in de risicovolle activamarkt stimuleert en aangeeft dat de inflatiedruk mogelijk afneemt.</p>
<p>Fed-beleid: Het puntmatrix toont aan dat de rentetarieven dit jaar slechts één keer zullen worden verlaagd en naar verwachting vier keer zullen worden verlaagd in 2025. Dit geeft aan dat de Federal Reserve nog steeds een voorzichtige houding heeft ten opzichte van het monetair beleid.</p>
<h3 id="h3-Markt20Hotspots760183"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>DePIN conceptleider IO: IO steeg bijna 50%, brak door $6, met een hoge leegstand van -0.1% op de contractmarkt. Gemeenschapsbronnen hebben onthuld dat IO binnenkort mogelijk een stakingfunctie zal lanceren, wat mogelijk verder prijsstijging stimuleert.</p>
<p>De AI-conceptsector is aanzienlijk hersteld onder leiding van Amerikaanse technologie aandelen, waarbij sectoren als LPT, RNDR, ARKM en andere goed presteren. Het herstel kan te wijten zijn aan het optimisme van de markt over toekomstige technologische ontwikkelingen.</p>
<p>BTC Inschrijving PIZZA: PIZZA is met 20% gestegen, met een aanzienlijke toename van de holdings van de topadressen. Als de eerste Meme van Unisat Wallet heeft PIZZA op dit moment een marktkapitalisatie van bijna $150 miljoen en staat hij op de 405e plaats.</p>
<p>Meme concept tokens: Meme tokens hebben een prominentere rol gespeeld in het marktherstel. De MOTHER en MANEKI van <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De keten steeg met meer dan 20% en de MAGA van Eth keten steeg op een gegeven moment met meer dan 30%. Er wordt gefluisterd dat Trump meer populariteit heeft in de presidentsverkiezingen, wat een stimulerend effect kan hebben op de gerelateerde Meme-tokens.</p>
<p>De huidige markt heeft een hoge volatiliteit en investeerders moeten voorzichtig handelen. De volatiliteit van de crypto markt is bijzonder opmerkelijk, vooral onder invloed van macro-economische gegevens en beleidsveranderingen. Investeerders moeten de markthotspots en -trends nauwlettend volgen terwijl ze de risico’s beheren bij deelname aan de markt.</p>
<h2 id="h2-Macro20De20SampP20500index20en20Nasdaqindex20bereikten20nieuwe20slotrecords20benvloed20door20CPI20en20de20Fed222938"><a name="Macro: De S&amp;P 500-index en Nasdaq-index bereikten nieuwe slotrecords, beïnvloed door CPI en de Fed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De S&amp;P 500-index en Nasdaq-index bereikten nieuwe slotrecords, beïnvloed door CPI en de Fed</h2><p>De belangrijke economische gegevens die op 12 juni zijn vrijgegeven, kwamen als een verrassing - het Amerikaanse ministerie van Arbeid meldde dat de Consumentenprijsindex (CPI) in mei onveranderd bleef vanwege een daling van de benzineprijzen.</p>
<p>De zwakker-dan-verwachte inflatiegegevens dreven de aandelenmarkt hoger bij de opening, waarbij de S&amp;P 500-index en de Nasdaq-index woensdag voor de derde opeenvolgende dag nieuwe slotrecords bereikten. Vanwege de voorspelling van de Federal Reserve van slechts één renteverlaging dit jaar vielen deze twee indices uiteindelijk terug van hun dagelijkse hoogtepunten.</p>
<p>De belangrijkste indicatoren zijn als volgt: de Dow Jones-index daalde met 0,1%, de S&amp;P 500-index steeg met 0,9% en de Nasdaq-index steeg met 1,5%.</p>
<p>De Fed heeft een tweedaagse beleidsvergadering afgerond, besloten de rentetarieven ongewijzigd te laten en een beleidsverklaring en Samenvatting van Economische Prognoses (SEP) uitgegeven. Na een toespraak van voorzitter van de Federal Reserve Jerome Powell tijdens een persconferentie, schommelde de aandelenmarkt, waarbij de S&amp;P 500- en NASDAQ-indexen hun winsten in de late handel verminderden, en de Dow Jones-index bijna vlak sloot. Na het vrijgeven van het CPI-rapport verhoogden handelaren hun weddenschappen op renteverlagingen van de Fed in september en december.</p>
<p>De herziene vooruitzichten van de Federal Reserve omvatten een afname van het aantal renteverlagingen dit jaar, een lichte stijging van het werkloosheidspercentage, en een stijging van de langetermijnbeleidsrente, wat leidde tot een aanzienlijke afkoeling op de aandelenmarkt, valutamarkten en obligatiemarkten in de latere handelsuren van woensdag in de Verenigde Staten. De prognose van de Federal Reserve voor maart omvat drie renteverlagingen, elk met 25 basispunten. Aan het einde van de vergadering van 11 tot 12 juni werd in de verklaring vermeld dat de beleidsrente ongewijzigd zou blijven, in overeenstemming met de verwachtingen van de markt.</p>
<p>Op 13 juni zal de Aziatische markt waarschijnlijk een impuls ontvangen omdat lagere dan verwachte inflatiecijfers in de VS het risicobereidheid van investeerders en schommelingen in de prijzen van activa hebben veroorzaakt. Echter, aangezien de nieuwe economische prognose van de Federal Reserve een havik-achtige houding heeft, kan dit momentum worden beperkt.</p>
<p>Onlangs is het cumulatieve effect van Chinese activa aanzienlijk geweest. De aanzienlijke daling van de aandelenmarkt en de RMB heeft staatsbanken ertoe aangezet om de Amerikaanse dollar te verkopen om de RMB te ondersteunen, wat investeerders twijfels heeft doen rijzen over China als investeringsbestemming. De Chinese aandelenmarkt is in de afgelopen drie weken met 5% gedaald, tweemaal zoveel als de MSCI Asia (exclusief Japan) index, en heeft aanzienlijk slechter gepresteerd dan de grotendeels vlakke Nikkei-index in Japan en de recordhoogte van de Amerikaanse en wereldwijde aandelenmarkten.</p>
<p>In de valutamarkt versterkten Aziatische valuta’s zich tegenover de Amerikaanse dollar op donderdag, behalve de Japanse yen, als gevolg van een lagere dan verwachte Amerikaanse inflatie. Voorafgaand aan de vergadering van de Bank of Japan, en aangezien Amerikaanse beleidsmakers lieten doorschemeren dat de rentetarieven nog geruime tijd hoog zouden blijven, bleef de yen onder druk staan.</p>
<p>Wat betreft grondstoffen daalden de olieprijzen op donderdagochtend omdat beleggers het nieuws verwerkten dat de Fed de rente op korte termijn niet zou verlagen. Voldoende voorraden ruwe olie en brandstof in de VS zetten verdere druk op de markt. Brent ruwe olie-futures daalden met 0,17% naar $82,46 per vat, terwijl West Texas Intermediate (WTI) futures met 0,2% daalden naar $78,34 per vat.</p>
<p>De prijs van goud steeg lichtjes nadat de Fed haar economische voorspelling bijwerkte, waarbij de spotprijs van goud met 0,2% steeg tot $2.320,76 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 standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen, mits Gate.io wordt vermeld. In alle glen zal juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>