RGFnZWxpamtzIG5pZXV3cyB8IExhbmdlIHRlcm1pam4gQlRDLWhvdWRlcnMgemlqbiBhbGxlbWFhbCB3aW5zdGdldmVuZCwga2FuIEFJLW1lbWVsZWlkZXIgR09BVCBkZSBtYXJrdCBsZWlkZW4/

2024-11-27, 04:38

<p><img src="https://gimg2.gateimg.com/image/article/173268219711.27.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETF20heeft20opnieuw20een20dagelijkse20uitstroom20van20meer20dan2010020miljoen20ervaren20waarbij20alle20BTChouders20op20lange20termijn20winst20maken994943"><a name="Crypto Dagelijkse Samenvatting: BTC ETF heeft opnieuw een dagelijkse uitstroom van meer dan $100 miljoen ervaren, waarbij alle BTC-houders op lange termijn winst maken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF heeft opnieuw een dagelijkse uitstroom van meer dan $100 miljoen ervaren, waarbij alle BTC-houders op lange termijn winst maken</h2><p>Volgens gegevens van Farside Investor, de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De spot ETF had gisteren een nettostroom van $122 miljoen. Fidelity FBTC had een nettostroom van $95,7 miljoen en Grayscale GBTC had een nettostroom van $36,1 miljoen.</p>
<p>Gisteren, de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De spot ETF had een kleine uitstroom van $9,5 miljoen. Grayscale ETHE had een uitstroom van $20,1 miljoen, Grayscale Mini Trust ETH had een instroom van $16,3 miljoen en de gegevens van BlackRock ETHA zijn nog niet bijgewerkt.</p>
<p><strong>Suilend native token SEND zal worden gelanceerd op 12 december</strong></p>
<p>Suilend, het uitleenprotocol van het Sui-ecosysteem, heeft aangekondigd dat SEND zal worden gelanceerd op 12 december en dat de toewijzingscontroleur is gelanceerd. Vroege gebruikers die Suilend gebruiken vóór de lancering van Points in mei 2024, ontvangen 2% SEND, waarbij Suilend-punten goed zijn voor 18% van SEND; Rootlets ontvangen 3,333% van SEND, verdeeld over drie airdrops van elk 1,111%.</p>
<p><strong>Pantera oprichter: <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> kan tegen april 2028 $740.000 bereiken</strong></p>
<p>Pantera-oprichter Dan Morehead voorspelt dat met de terugkeer van de gekozen Amerikaanse president Donald Trump, die blockchain ondersteunt, naar het Witte Huis, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> kan stijgen tot $740.000.</p>
<p>Morehead verklaarde dat haar Pantera <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Fund, dat zich richt op cryptocurrency, sinds de oprichting in 2013 een historisch rendement van 131.165% heeft behaald. “Bitcoin heeft drie ordes van grootte van groei bereikt”, zei hij, “en het lijkt mogelijk om het opnieuw te doen.”</p>
<p>Volgens de theorie van Morehead bevindt Bitcoin zich altijd op een trendlijn. Als het zijn groeipatroon blijft behouden, kan de prijs tegen april 2028 $740.000 bereiken. Sinds Pantera begon te investeren, is Bitcoin bijna elk jaar verdubbeld, met een <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">samengesteld</a> jaarlijkse groeipercentage van ongeveer 88%.</p>
<p>Hij voegde eraan toe: ‘Vergeleken met $500 biljoen aan financiële activa is dit aantal niet onvoorstelbaar.’ Bij een prijs van $740.000 zal de marktkapitalisatie van Bitcoin $15 biljoen bereiken.</p>
<p><strong>Glassnode: Alle 14 miljoen BTC die worden vastgehouden door langetermijnbeleggers zijn winstgevend geworden</strong></p>
<p>Volgens gegevens die zijn vrijgegeven door Glassnode, zijn alle 14 miljoen BTC die worden vastgehouden door langetermijnbeleggers in een winstgevende staat terechtgekomen naarmate de prijs van Bitcoin stijgt. Dit heeft de versnelling van verkoopactiviteiten gestimuleerd en geleid tot een aanzienlijke daling van het saldo van meer dan 200.000 BTC sinds het doorbreken van historische hoogtepunten.</p>
<p>Lange termijn houders beginnen winst te nemen wanneer de prijzen sterk zijn en er voldoende vraag is om ze op te vangen. ETF’s spelen een belangrijke rol in dit proces, waarbij ze meer dan 90% van de verkoopdruk van lange termijn houders absorberen. Echter, naarmate de niet-gerealiseerde winsten extreme niveaus bereiken, wordt verwacht dat lange termijn houders hun verkoop zullen versnellen, wat op korte termijn de instroom van ETF’s overtreft.</p>
<p>Vanwege de grote hoeveelheid Bitcoin die nog steeds in handen is van langetermijnhouders, wachten veel langetermijnhouders mogelijk op hogere prijzen voordat ze meer Bitcoin terug in omloop brengen.</p>
<h2 id="h2-Markttrends20Laag20120steeg20collectief20GOAT20herstelde20zich20aanzienlijk549800"><a name="Markttrends: Laag 1 steeg collectief, GOAT herstelde zich aanzienlijk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Laag 1 steeg collectief, GOAT herstelde zich aanzienlijk</h2><h3 id="h3-Markt20Hotspots506634"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>AI-memekoploper GOAT herstelde aanzienlijk, met een intraday-amplitude van bijna 30%. De huidige circulerende marktkapitalisatie van GOAT is $830 miljoen, wat op de 151e plaats staat in de gehele markt; AI blijft een van de belangrijkste verhalen in deze ronde van markttrends, en in vergelijking met toonaangevende projecten op het gebied van AI zoals NEAR en FET, heeft GOAT nog steeds veel ruimte voor verbetering;</p>
<p>Layer1 openbare ketens zoals INR, FTM, ALGO en SEI zijn gezamenlijk gestegen. INR is een gevestigde openbare keten en hoewel het niet veel ecosysteem op de keten heeft, heeft het sterke fondsen erachter, zelfs een 50-voudige stijging in bearmarkten gecreëerd; SEI is een nieuwe openbare keten in deze markttrendronde, met een circulerende marktkapitalisatie van $2,9 miljard, en staat op de 47e plaats in de hele markt;</p>
<p><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> staking protocol leider EIGEN steeg met 10% in 24 uur. EIGEN heeft een lage liquiditeitsratio met een marktkapitalisatie van slechts $640 miljoen, maar de FDV is zo hoog als $5.7 miljard. Als ETH ETF’s in de toekomst staking toestaan op beleidsniveau, kunnen fondsen zich in de re-staking protocollen storten.</p>
<h3 id="h3-Mainstream20Munten668878"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC handelt nog steeds nauw rond $93.000, waarbij de meeste BTC-spot-ETF’s netto-uitstroom ervaren, behalve BlackRock;</p>
<p>De kracht van ETH duurde niet lang en de daling op de markt dreef ETH terug naar ongeveer $3.350. ETH moet nog steeds wachten tot BTC door de psychologische marktbarrière van $100.000 breekt voordat het een onafhankelijke marktprestatie kan hebben;</p>
<p>Altcoins raakten de bodem en herstelden zich vervolgens, terwijl vroege sterke tokens zoals GOAT en MOODENG herstelden.</p>
<h2 id="h2-Macro20nieuws20Amerikaanse20aandelen20sloten20gezamenlijk20hoger20met20de20verwachtingen20van20een20renteverlaging20van20de20Fed20die20stijgt20tot20628163732"><a name="Macro nieuws: Amerikaanse aandelen sloten gezamenlijk hoger, met de verwachtingen van een renteverlaging van de Fed die stijgt tot 62,8%." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Amerikaanse aandelen sloten gezamenlijk hoger, met de verwachtingen van een renteverlaging van de Fed die stijgt tot 62,8%.</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten gezamenlijk hoger af, waarbij de S&amp;P 500-index met 0,57% steeg tot 6.021,63 punten; De Dow Jones Industrial Average steeg met 0,28% tot 44.860,31 punten; De Nasdaq-index steeg met 0,63% en sloot af op 19.174,30 punten. Het referentiepercentage voor 10-jarige staatsleningen bedraagt 4,30%, terwijl het percentage voor 2-jarige staatsleningen, dat het meest gevoelig is voor het rentetarief van de Federal Reserve, 4,21% bedraagt.</p>
<p>De Federal Reserve heeft de notulen van de vergadering van het Federal Open Market Committee (FOMC) van 6 tot 7 november vrijgegeven. Volgens de notulen van de vergadering wordt voorspeld dat de Federal Reserve de rente in december met nog eens 25 basispunten kan verlagen. Uit de notulen van de vergadering bleek dat de Federal Reserve tijdens haar vergadering in november besloot haar doelbereik voor de federal funds rate met 25 basispunten te verlagen, waardoor haar benchmarkrente op 4,5% tot 4,75% kwam. De Fed verklaarde ook dat verdere aanpassingen van haar monetaire beleidskoers zouden helpen om de kracht van de economie en de arbeidsmarkt te behouden en tegelijkertijd de inflatie verder te verlagen. Volgens CME’s “FedWatch” is de kans dat de Fed de huidige rente tot december ongewijzigd laat 37,2% en de kans op een cumulatieve renteverlaging met 25 basispunten 62,8%.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>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. Alle beleggingen brengen inherente risico's met zich mee; verstandig besluitvorming is essentieel.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>