RGFnZWxpamtzIG5pZXV3cyB8IEJpdGNvaW4gc3RlZWcgbmFhciBvbmdldmVlciAkNjksMDAwLCB3YWFyYmlqIGhldCBvcHRpbWlzbWUgc25lbCBoZXJzdGVsZGU7IFRydW1wIHVpdHRlIHBvc2l0aWV2ZSBzdGFuZHB1bnRlbiBvdmVyIEJUQyBvcCBkZSBCaXRjb2luLWNvbmZlcmVudGll

2024-07-29, 03:18

<p><img src="https://gimg2.gateimg.com/image/article/17222230381_22.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20rentebeslissing20van20de20Fed20wordt20aanstaande20donderdag20bekendgemaakt20en20de20waarschijnlijkheid20dat20de20Fed20deze20week20de20rente20ongewijzigd20houdt20is2095920Afgelopen20vrijdag20heeft20de20Amerikaanse20spot20Bitcoin20ETF20zijn20bezittingen20met2063020BTC20verhoogd135129"><a name="Crypto Dagelijkse Samenvatting: De rentebeslissing van de Fed wordt aanstaande donderdag bekendgemaakt, en de waarschijnlijkheid dat de Fed deze week de rente ongewijzigd houdt, is 95,9%; Afgelopen vrijdag heeft de Amerikaanse spot Bitcoin ETF zijn bezittingen met 630 BTC verhoogd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De rentebeslissing van de Fed wordt aanstaande donderdag bekendgemaakt, en de waarschijnlijkheid dat de Fed deze week de rente ongewijzigd houdt, is 95,9%; Afgelopen vrijdag heeft de Amerikaanse spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF zijn bezittingen met 630 BTC verhoogd</h2><p>Op donderdag 1 augustus om 2:00 uur Hong Kong tijd zal de Federal Reserve een rentebesluit nemen. Mensen verwachten dat de functionarissen van de Federal Reserve deze week de belangrijkste rente ongewijzigd zullen laten. UBS is van mening dat de beleidswijziging van de Federal Reserve aanstaande is, met een basisprognose van een renteverlaging van 25 basispunten voor de eerste keer in september.</p>
<p>Volgens de ‘Federal Reserve Watch’ van CME is de kans dat de Federal Reserve deze week de rente ongewijzigd houdt 95,9%, en de kans dat de rente met 25 basispunten wordt verlaagd 4,1%. De kans dat de Federal Reserve de rente ongewijzigd houdt tot september is 0%, de kans op een cumulatieve renteverlaging van 25 basispunten is 87,7%, de kans op een cumulatieve renteverlaging van 50 basispunten is 11,9%, en de kans op een cumulatieve renteverlaging van 75 basispunten is 0,4%.</p>
<p>Op 26 juli, negen VS <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">Ethereum-munten](/price/</a><a  rel="nofollow noopener noreferrer"  href=")-eth”" target="“_blank”" class="“blog" _inner_="" [link<="" a=""> Ethereum ETF’s verminderden hun bezittingen met 37.044 ETH, terwijl </a><a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">bitcoin</a>-btc” target=“_blank” class=“blog_inner_link”&gt;Bitcoin ETFs hebben hun bezit met 630 BTC verhoogd.</p>
<p>Vaneck voorspelt dat de prijs van Bitcoin tegen 2050 $2,9 miljoen zal bereiken. Het rapport geeft aan dat Bitcoin 10% van de wereldwijde internationale handel en 5% van de binnenlandse handel kan afhandelen, waarbij centrale banken 2,5% van de activa in de vorm van BTC aanhouden. Schaalbaarheidsuitdagingen zijn het vermelden waard, maar de oplossing van de tweede laag kan de adoptiepercentages verbeteren.</p>
<p>De token, ter waarde van ongeveer $ 893 miljoen, wordt in augustus ontgrendeld, gevolgd door de release van <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a>, ter waarde van maximaal $268 miljoen, en Wormhole, ter waarde van meer dan $180 miljoen.</p>
<p>Volgens tonscan-gegevens heeft het TON-netwerk momenteel 677 miljoen TON gestaked, wat overeenkomt met 26,9% van de circulerende voorraad (2,5165 miljard TON). Bovendien is de huidige gestakte APY 3,7% en zijn er in totaal 400 verificatieknooppunten in het netwerk.</p>
<p>Tijdens de Bitcoin2024-conferentie verklaarde Donald Trump Jr., de oudste zoon van Trump, dat Bitcoin een middel is om zich te beschermen tegen inflatie en autoritaire regeringen.</p>
<p>De eigenaar van Kabosu, het prototype van de Doge meme, <a href="/price/shiba-inu-shib" rel="nofollow noopener noreferrer" target="_blank">Shiba Inu</a>, verklaarde dat zij geen goedkeuring geven aan andere crypto-projecten dan Own The Doge.</p>
<p>BlackRock IBIT en Fidelity FBTC behoren tot de top 10 ETF’s wat betreft kapitaalinstroom dit jaar, met de hoogste rendementen.</p>
<p>Volgens Dune-gegevens heeft BLOCKLORDS ooit meer dan 250.000 dagelijkse actieve gebruikers op de Base-keten overtroffen en is het een van de belangrijkste spellen op de keten geworden.</p>
<p>De officiële website van NetX, gebouwd door het AI-cloudcomputing-infrastructuur Trias ecosysteemproject, is officieel gelanceerd op 26 juli. Het NetX-mainnet wordt binnenkort gelanceerd aan het einde van juli.</p>
<p>EigenLayer, het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> herstakingsprotocol, heeft aangekondigd op het X-platform dat het binnenkort AVS (Active Verification Service) beloningen en EIGEN programmatische prikkels zal lanceren.</p>
<h2 id="h2-Markttrends20BTC20schoot20omhoog20naar20ongeveer206900020wat20wijst20op20een20snelle20herstel20van20het20bullish20sentiment20op20de20markt335700"><a name="Markttrends: BTC schoot omhoog naar ongeveer $69.000, wat wijst op een snelle herstel van het bullish sentiment op de markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC schoot omhoog naar ongeveer $69.000, wat wijst op een snelle herstel van het bullish sentiment op de markt</h2><p>Bitcoin (BTC) zag een matige stijging tijdens het weekend, waarbij dagelijkse, 4-uurlijke en 1-uurlijke niveaus een bullish trend met voortschrijdende gemiddelden lieten zien. Als deze momentum deze week aanhoudt, wordt verwacht dat het de vorige hoogte van ongeveer $70.000 zal bereiken voordat het wordt gestopt en rust krijgt.</p>
<p>Vanuit puur technisch oogpunt heeft Bitcoin minder dan 8% ruimte om zijn hoogste doel hierboven te bereiken, maar zodra het stabiliseert op $73.000, zal de bovenruimte openen. Echter, op basis van eerdere historische ervaring heeft Bitcoin nog steeds een zekere verwachting van neerwaartse verkenning en ondersteuningsaanpassing gezien de opwaartse kloof in CME-futures deze week en drie dagelijkse niveaukloven.</p>
<p>Vanuit het perspectief van kapitaal <a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">stroom</a>-flow” target=“_blank” class=“blog_inner_link”&gt;flow, Amerikaanse spot ETF’s hebben in juli een voortdurende nettostroom van fondsen laten zien, wat wijst op een lichte opleving van het marktsentiment. De markt is geleidelijk hersteld van de paniek veroorzaakt door de terugbetaling van Bitcoin-schulden door Mt.Gox en de verkoop van de Duitse overheid.</p>
<p>Het is vermeldenswaard dat op basis van recente economische gegevens de inflatie inderdaad afneemt. Powell, die er eerder toe neigde eerder actie te ondernemen, weegt nu de risico’s van te vroeg renteverlagingen en te lang wachten af. De huidige situatie duidt erop dat de Federal Reserve begint te neigen naar snellere renteverlagingen. Het geloof in verbetering van de macro liquiditeit zal helpen om verdere bullish sentiment in Bitcoinprijzen te stimuleren.</p>
<p>Samenvattend zal Bitcoin vanuit een macro-perspectief nog steeds voldoende bullische momentum ontvangen, maar het kan op korte termijn een bepaalde correctietrend handhaven, en de langetermijnvooruitzichten voor de toekomst zijn nog steeds optimistisch.</p>
<h3 id="h3-Markt20Hotspots185672"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Betalingssector: De betalingssector leidde de markt iets hoger, met een stijging van 1,4% in 24 uur. <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a>, BCH, LTC en andere toonaangevende sectoren zagen hun respectieve winsten van 1,07%, 6,18% en 0,42%. Deze veteraan tokens hebben een relatief ingetogen prestatie, en de duurzaamheid van de hete topic rotatie in deze sector moet mogelijk verbeterd worden.</p>
<p>Layer1 sector: De huidige marktwaarde van de Layer1 sector is 10.03%, met een stijging van 0.68% in 24 uur. <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>, SOL, ADA, TR,X en andere cryptocurrencies hebben een relatief sterke prestatie laten zien.</p>
<p>MEME sector: Onlangs heeft de MEME sector als eerste de sterke marktherstel gevolgd. Hoewel er ups en downs zijn geweest, is de MEME sector geleidelijk verbeterd en zullen er altijd nieuwe MEMEs zijn die tegen de trend in stijgen. Momenteel hebben BOME, PONKE, MUMU, COQ en andere sectoren opmerkelijke winsten laten zien, met respectievelijk 24-uurs winsten van 5,9%, 16,7%, 12,9% en 17,3%.</p>
<p>Over het algemeen zijn de huidige macro liquiditeitsverwachtingen in de <a href="/price" rel="nofollow noopener noreferrer" target="_blank">crypto markt</a> zijn geleidelijk verbeterd. Na zeven opeenvolgende maanden van sterke winst, ervaart Bitcoin momenteel een breed scala aan schommelingen, waarbij verschillende sectoren een speculatieve rotatie behouden. Er is geen bewijs dat er momenteel een situatie is waarin de populariteit van AI, DePIN en Inion blijft overstromen zoals vorig jaar. Momenteel is kapitaalspeculatie nog steeds voorzichtig en de markt zoekt mogelijk iconische producten die markttrends kunnen ontsteken. MEME-mini-games op de TON-keten zijn het waard om te volgen.</p>
<p>Over het algemeen zijn de huidige macroliquiditeitsverwachtingen op de cryptomarkt geleidelijk verbeterd. Na zeven opeenvolgende maanden van sterke winsten, ervaart Bitcoin momenteel een breed scala aan schommelingen, waarbij verschillende sectoren een speculatieve rotatie handhaven. Er is geen bewijs om aan te geven dat er momenteel een situatie is waarin de populariteit van AI, DePIN en Inion blijft overstromen zoals vorig jaar. Op dit moment is kapitaalspeculatie nog steeds voorzichtig en de markt zoekt mogelijk iconische producten die markttrends kunnen ontsteken. MEME-mini-games op het TON-netwerk zijn het waard om op te letten.</p>
<h2 id="h2-Macro20Bitcoin20Conference20verwelkomt20toespraak20van20Trump20macro20liquiditeit20versoepeling20pijl20op20de20lijn113582"><a name="Macro: Bitcoin Conference verwelkomt toespraak van Trump, macro liquiditeit versoepeling pijl op de lijn" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Bitcoin Conference verwelkomt toespraak van Trump, macro liquiditeit versoepeling pijl op de lijn</h2><p>Vorige week waren de nieuwste financiële rapporten van Google en Tesla niet bevredigend, wat speculatie over het ‘barsten van de kunstmatige intelligentie-schuim’ op de markt veroorzaakte en de volatiliteit op de Amerikaanse aandelenmarkt verhoogde. Wat betreft prijsrendementen steeg de Dow Jones Industrial Average vorige week met 0,75%, daalde de Nasdaq met 2,08% en daalde de S&amp;P 500-index met 0,83%. De koppeling tussen de crypto- en de Amerikaanse aandelenmarkten verzwakte echter verder, met een sterke prestatie vorige week na een daling.</p>
<p>De recente Bitcoin-conferentie van 2024 heeft marktaandacht getrokken. Trump hield een toespraak op de conventie waarin hij zijn positieve kijk op Bitcoin uitte, waarbij hij het een ‘wonder van samenwerking en menselijke prestatie’ noemde, en beloofde een reeks maatregelen te nemen ter ondersteuning van de ontwikkeling van het cryptoveld als hij tot president wordt gekozen, waaronder het instellen van Bitcoin als een strategische asset, het ontwikkelen van energie om de mijnkosten te verlagen, en het benoemen van het Bitcoin / Cryptocurrency Presidential Advisory Committee. Hij voorspelde ook dat de marktwaarde van Bitcoin in de toekomst die van goud zou overtreffen en beloofde een nationale strategische Bitcoin-reserve op te richten.</p>
<p>Te midden van speculatie over mogelijke veranderingen in het Bitcoin-beleid van Trump, steeg de waarde van cryptocurrency tot meer dan $69.000 op zaterdag.</p>
<p>Het is echter vermeldenswaard dat na het bijwonen van de Bitcoin-conferentie door Trump, meerdere gerelateerde Trump-conceptmunten een algemene daling hebben ervaren.</p>
<p>Aan de andere kant, in het licht van zwakke inflatiegegevens en oververhitte werkgelegenheidsgegevens, is na het afwegen van meerdere factoren de verwachting van renteverlagingen van de Federal Reserve geleidelijk duidelijk geworden. De Federal Reserve is zeer voorzichtig in haar houding ten opzichte van werkgelegenheidsgegevens en hoopt op een zachte landing op de arbeidsmarkt en handhaaft hoge rentetarieven om de inflatie te onderdrukken. Het rapport van het non-farm payroll van juni sluit aan bij het verwachte doel van de Federal Reserve, en de marktanalyse gelooft over het algemeen dat de Fed in september de rente kan verlagen. De Federal Reserve staat echter voor een dilemma bij het beslissen om de rente te verlagen: als de arbeidsmarkt te snel afkoelt, kan de Fed gedwongen worden om vroegtijdig de rente te verlagen om non-farm payroll en werkloosheidscijfers te redden; Als de arbeidsmarkt heet blijft, moet de Federal Reserve mogelijk doorgaan met het verlengen van haar beleid van hoge rentetarieven.</p>
<p>Desalniettemin zorgen gunstige inflatie, afkoelende arbeidsmarkten en veranderende overwegingen van dubbele risico’s ervoor dat de Federal Reserve zich voorbereidt op renteverlagingen.</p>
<p>De rentebeslissing van de Federal Reserve zal deze donderdag worden aangekondigd en Powell zal een persconferentie over het monetaire beleid houden. Er wordt verwacht dat het beleid verder zal worden verduidelijkt.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel te herplaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>