RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBFVEYgaW5zdHJvb20gb3ZlcnNjaHJlZWQgJDgwMCBtaWxqb2VuIG9wIMOpw6luIGRhZywgQlRDIGJlcmVpa3RlIGVlbiBuaWV1d2UgaGlzdG9yaXNjaGUgaG9vZ3RlcHVudCBiaW5uZW4gZGUgZGFn

2024-11-20, 04:55

<p><img src="https://gimg2.gateimg.com/image/article/173207838511.20.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Inflows20van20BTC20ETF20overschreden2080020miljoen20op20n20dag20markt20blijft20uiterst20hebzuchtig752241"><a name="Crypto Dagelijkse Samenvatting: Inflows van BTC ETF overschreden $800 miljoen op één dag, markt blijft uiterst hebzuchtig" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Inflows van BTC ETF overschreden $800 miljoen op één dag, markt blijft uiterst hebzuchtig</h2><p>Volgens Farside Investor-gegevens, Amerikaanse spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s hadden gisteren een nettostroom van $815 miljoen. BlackRock IBIT had een nettostroom van $213 miljoen, Fidelity FBTC had een nettostroom van $256 miljoen en Ark ARKB had een nettostroom van $265 miljoen.</p>
<p>Gisteren heeft de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Uitstroom van spot ETF was $81 miljoen. De uitstroom van BlackRock’s ETHA bedroeg $14,23 miljoen, de uitstroom van Fidelity’s FETH bedroeg $46,7 miljoen en de uitstroom van Grayscale’s ETHE bedroeg $20,4 miljoen.</p>
<p><strong>Bloomberg analist: handelaren wedden <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> zal volgende maand verdubbelen</strong></p>
<p>Bloomberg senior ETF-analist Eric Balchunas schreef op X-platform: ‘Tot nu toe heeft het handelsvolume in opties op BlackRock IBIT enkele honderden miljoenen dollars bereikt (veel op de eerste dag van de notering). Volgens de ranglijst van het handelsvolume van contracten zijn bijna al deze call-opties. Het ziet er zeer optimistisch uit, vooral de C100 op 20 december, wat in feite een weddenschap is op de prijs van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> zal volgende maand verdubbelen.</p>
<p><strong>Medeoprichter Shaw van AI16Z: Sommige leden hebben aanzienlijke winsten behaald door de uitgifte van Eliza, en het team zal de projectontwikkeling blijven bevorderen</strong></p>
<p>AI16Z mede-oprichter Shaw reageerde op het geschil over de uitgifte van de Eliza-token in een bericht: ‘Ik heb samengewerkt met onze releasepartner en geprobeerd chips te kopen toen Eliza werd uitgebracht, maar ontving niet veel. Iemand in ons team heeft echter een aanzienlijk bedrag aan inkomsten ontvangen en heeft ermee ingestemd dit over te dragen aan de DAO en het team, dus we hebben genoeg geld om onze luchtdropverplichtingen aan andere projecten te vervullen en de Eliza-teamactiviteiten te onderhouden.’</p>
<p>Shaw zei: “Hoewel het betreurenswaardig is dat het project voortijdig is uitgegeven, gezien de belangen van de houders, heeft het oorspronkelijke team een samenwerkingsovereenkomst bereikt met de relevante uitgever en beloofd om 10% van de voorraad als compensatie aan de oorspronkelijke tokenhouders te luchten. Het nieuwe team zal zich bij het Eliza-project voegen als codebijdrager en zich richten op het ondersteunen bij de ontwikkeling van metanarratieve tools. Het Eliza-project is vele jaren voorbereid en hoewel dit evenement betreurenswaardig is, zal het team blijven werken aan de ontwikkeling van het project, waarbij wordt gegarandeerd dat de token vrij stroomt en niet wordt gecontroleerd door een individu of organisatie.”</p>
<p><strong>De omvang van het vermogen van BlackRock IBIT is de afgelopen 7 dagen met 38% gestegen en is daarmee de snelst groeiende ETF in de geschiedenis geworden.</strong></p>
<p>Volgens Fox Business blijkt uit gegevens van de Dow Jones Market Data Group dat het grootste <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF, BlackRock IBIT, op 14 november $42 miljard aan activa had, een stijging van 38% in de afgelopen zeven dagen. Deze ontwikkeling heeft de prijs van het ETF (aandelen code IBIT) naar een historisch hoogtepunt geduwd, en het wordt momenteel beschouwd als de snelst groeiende ETF in de geschiedenis.</p>
<p>Een woordvoerder van BlackRock zei: ‘Sinds de lancering heeft de instroom van geld in IBIT de neiging van beleggers benadrukt om te investeren in Bitcoin via het gemak en de kwaliteit van ETF’s. De verwachting van positieve regelgevende actie tegen Bitcoin en cryptocurrencies heeft opnieuw aangewakkerd in de markt.’ <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">optimisme</a>. We blijven ons richten op het educeren van investeerders en het bieden van handige en transparante Bitcoin-investeringskanalen.</p>
<p>Volgens het bedrijf heeft IBIT sinds de verkiezing meer dan $3 miljard aan activa aangetrokken. Het presidentschap van Donald Trump wordt verwacht een regering te brengen die meer steun verleent aan cryptocurrency.</p>
<h2 id="h2-Markttrends20Algorithmische20stablecoin20USUAL20werd20gelanceerd20MOODENG20ACT20en20andere20belangrijke20daalden785300"><a name="Markttrends: Algorithmische stablecoin USUAL werd gelanceerd, MOODENG, ACT en andere belangrijke daalden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Algorithmische stablecoin USUAL werd gelanceerd, MOODENG, ACT en andere belangrijke daalden</h2><h3 id="h3-Markt20Hotspots101714"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>Het algoritme-stabiele muntprotocol USUAL is gelanceerd, met een huidige circulerende marktkapitalisatie van $150 miljoen en een totale circulerende marktkapitalisatie van meer dan $1 miljard. De huidige circulerende marktkapitalisatie van ENA, een belangrijke speler in dezelfde sector, bedraagt $1,5 miljard; Ondanks de vorige LUNA-storm is de markt nog steeds op zoek naar oplossingen voor algoritmische stabiele munten, maar de prestaties van USUAL zijn gemiddeld en de markt koopt het verhaal van dit type VC-munt niet meer.</p>
<p>De AI meme-leidende token GOAT liet een sterke prestatie zien, daalde gisteren tot ongeveer $1 en herstelde aanzienlijk met 20%. Het zweeft momenteel rond $1.2 en heeft een huidige circulerende marktwaarde van $1.15 miljard. We zullen observeren of GOAT de leidende token zal worden in deze ronde van markttrends;</p>
<p>Trending coins zoals MOODENG en ACT hebben een scherpe daling ervaren in het beginstadium, terwijl gevestigde munten zoals XTZ stegen; De daling van leidende munten en de stijging van gevestigde munten duiden beide op het einde van de kortetermijnmarkt, en de markt zal een periode van volatiliteit ingaan, in afwachting van de opkomst van een nieuw verhaal.</p>
<h3 id="h3-Mainstream20Munten606046"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC brak ooit door de $93.900 en bleef een nieuw historisch hoogtepunt vestigen, maar is nu lichtjes gedaald tot ongeveer $91.500. BTCD bereikte 59,2% en staat nog steeds op een historisch hoogtepunt. Wanneer BTCD aanzienlijk daalt, is het het prestatie moment van altcoins;</p>
<p>ETH is gezakt tot onder de $3.100 en bevindt zich nog steeds in een smalle fluctuatiezone. ETH moet nog steeds wachten tot BTC zijn historische hoogte doorbreekt voordat het een onafhankelijke prijsprestatie kan hebben;</p>
<p>Altcoins daalden over het algemeen en de markt ontbreekt een blijvend verhaal. AI-memes presteren nog steeds goed.</p>
<h2 id="h2-Macro20nieuws20de20Amerikaanse20aandelenmarkt20daalde20licht20Nvidia20zal20vandaag20financieel20rapport20aankondigen637130"><a name="Macro nieuws: de Amerikaanse aandelenmarkt daalde licht, Nvidia zal vandaag financieel rapport aankondigen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: de Amerikaanse aandelenmarkt daalde licht, Nvidia zal vandaag financieel rapport aankondigen</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt schommelden, waarbij de S&amp;P 500-index met 0,40% steeg tot 5.916,98 punten; De Dow Jones Industrial Average daalde met 0,28% tot 43.268,94 punten; De Nasdaq-index steeg met 1,04% tot 18.987,47 punten. Het referentiepunt van de 10-jarige schatkistrendement bedraagt 4,39%, terwijl het 2-jarige schatkistrendement, het meest gevoelig voor het beleidspercentage van de Federal Reserve, 4,27% bedraagt.</p>
<p>Nvidia zal zijn financieel rapport over het derde kwartaal bekendmaken na de lokale tijd op woensdag. Nvidia wordt beschouwd als een van de meest dominante aandelen op de Amerikaanse aandelenmarkt en de financiële prestaties trekken wereldwijd aandacht van de markt. Strategen van Bank of America Securities voorspellen dat de winst van Nvidia mogelijk een groter risico vormt voor de S&amp;P 500-index dan de volgende gegevens over de werkgelegenheid in de landbouw, CPI of de vergadering van de Federal Reserve.</p>
<p>Volgens Bloomberg is Trump Media Technology Group, een dochteronderneming van Trump, in gesprek om digitale activaplatform Bakkt Holdings Inc. over te nemen. Andere ontwikkelingen zijn onder andere de initiële notering van iShares Bitcoin Trust ETF (IBIT) opties onder BlackRock op de NASDAQ-beurs op dinsdag lokale tijd. IBIT is momenteel de grootste Bitcoin spot ETF qua omvang.</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 investeringen 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 wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>