RGFnZWxpamtzIG5pZXV3cyB8IE5pZXV3ZSBDb2luIE1FIHN0ZWVnIG1ldCBtZWVyIGRhbiAxMDAlIG5hIGxhbmNlcmluZywgbWFya3QgdmVyd2FjaHQgb3ZlciBoZXQgYWxnZW1lZW4gZGF0IGRlIEZlZCBkZSByZW50ZXRhcmlldmVuIG1ldCAyNSBiYXNpc3B1bnRlbiB6YWwgdmVybGFnZW4u

2024-12-11, 03:22

<p><img src="https://gimg2.gateimg.com/image/article/173388717212.11.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETF20en20ETH20ETF20blijven20grote20instromen20ervaren20en20ME20airdrop20tokens20zijn20nu20beschikbaar20om20te20claimen349342"><a name="Crypto Dagelijkse Samenvatting: BTC ETF en ETH ETF blijven grote instromen ervaren, en ME airdrop tokens zijn nu beschikbaar om te claimen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF en ETH ETF blijven grote instromen ervaren, en ME airdrop tokens zijn nu beschikbaar om te claimen</h2><p>Volgens de gegevens van Farside Investor bedroeg de nettostroom van de Amerikaanse spot BTC ETF gisteren $437 miljoen. De instroom van BlackRock’s IBIT was $294 miljoen en de nettostroom van Fidelity’s FBTC was $210 miljoen.</p>
<p>Gisteren heeft de VS <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De instroom van spot ETF was $303 miljoen. De instroom van BlackRock’s ETHA was $80 miljoen en de netto instroom van Fidelity’s FETH was $202 miljoen.</p>
<p><strong>De ME airdrop moet worden geclaimd op de Magic Eden App en de gekoppelde portemonnee verloopt op 1 februari 2025</strong></p>
<p>De ME Foundation heeft een verklaring uitgegeven waarin staat dat ME airdrops moeten worden verzameld via de Magic Eden mobiele applicatie. Als de gebruiker al alle wallets heeft gekoppeld, hoeven ze alleen de applicatie te laden om ME te claimen.</p>
<p>Als de gebruiker zijn portemonnee nog niet heeft gekoppeld, geen zorgen. Je kunt <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">link</a> uw portemonnee en verzamel ME op elk moment tussen TGE en 1 februari 2025.</p>
<p>Als gebruikers ontdekken dat er mogelijk andere portefeuilles beschikbaar zijn voor distributie na ontvangst van ME-tokens, kunnen ze <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">link</a> deze portefeuilles via het bureaublad na TGE en verzamel deze tokens in de mobiele applicatie.</p>
<p><strong><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> L2 Fuel heeft zijn inheemse token FUEL gelanceerd.</strong></p>
<p>Het high-performance <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> L2-netwerk Fuel heeft de lancering van zijn eigen token Fuel aangekondigd, en Fuel Genesis komt binnenkort.</p>
<p>Fuel garandeert een gedecentraliseerd sorteersysteem voor Fuel en elimineert gas kosten voor gebruikers door een nieuwe economische stimuleringsstructuur te introduceren op basis van Application Specific Sequencing. FUEL zal het Ignition-ecosysteem veranderen door gebruikers een kosteloze ervaring te bieden die vergelijkbaar is met Web2, waardoor blockchain technologie toegankelijk wordt voor het publiek. Fuel Ignition is de snelste (&gt;600 TPS) en goedkoopste (&lt;0.002 USD per transactie) Optimal Rollup-oplossing op Ethereum.</p>
<p><strong><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>: USDT erkend als acceptabele virtuele activa door Abu Dhabi Global Market</strong></p>
<p><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Binden</a> De stablecoin-uitgever heeft aangekondigd dat zijn USDT is erkend als een ‘Acceptable Virtual Asset’ (AVA) door de Financial Services Regulatory Authority (FSRA) van de Abu Dhabi Global Markets (ADGM). Deze goedkeuring stelt door FSRA bevoegde instellingen in staat om vooraf goedgekeurde diensten met betrekking tot USDT te verlenen, waardoor de leidende positie van de regio op het gebied van digitale activa-innovatie wordt versterkt.</p>
<p>Deze aankondiging komt op een moment dat de adoptiesnelheid van digitale valuta in de Verenigde Arabische Emiraten (VAE) groeit, wat de actieve bevordering van de integratie van traditionele en digitale financiën in het land weerspiegelt. De Dirham van de Verenigde Arabische Emiraten is gekoppeld aan de Amerikaanse dollar en dient als benchmark voor wereldwijde economische stabiliteit. Tether’s USDT heeft momenteel een marktkapitalisatie van meer dan $138 miljard, waardoor het wereldwijd de meest gebruikte stablecoin is. Met meer dan 400 miljoen gebruikers die USDT gebruiken, vult het de stabiliteit van de Verenigde Arabische Emiraten aan door een betrouwbare en efficiënte brug te bieden tussen traditionele fiatvalutaen en de digitale economie.</p>
<p>Sinds 2022 is het adoptiepercentage van cryptocurrencies in de Verenigde Arabische Emiraten sterk toegenomen. Het progressieve regelgevingskader heeft steden als Abu Dhabi en Dubai tot wereldleiders gemaakt in crypto-innovatie en blockchain-technologie, waardoor een vruchtbare voedingsbodem is ontstaan voor de ontwikkeling van digitale activa-ecoen.</p>
<h2 id="h2-Markttrends20De20lancering20van20de20nieuwe20munt20ME20liet20indrukwekkende20prestaties20zien20terwijl20Altcoins20wachten20op20een20herstel20voordat20ze20weer20gaan20kopen484125"><a name="Markttrends: De lancering van de nieuwe munt ME liet indrukwekkende prestaties zien, terwijl Altcoins wachten op een herstel voordat ze weer gaan kopen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De lancering van de nieuwe munt ME liet indrukwekkende prestaties zien, terwijl Altcoins wachten op een herstel voordat ze weer gaan kopen</h2><h3 id="h3-Markt20Hotspots727474"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>-Na de lancering van de nieuwe munt ME op Gate.io, steeg het van $4,1 naar $9,1, met een stijging van meer dan 100% in 24 uur, waarmee het de markt leidde. ME is de platformtoken van Magic Eden, het grootste NFT-handelsplatform op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> chain. De vorige NFT-platform token TNSR op de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> De ketting is sinds de lancering in april van dit jaar helemaal glen en de huidige marktkapitalisatie is slechts $80 miljoen;</p>
<p>-De Meme Coin KOMA steeg met 150% binnen de dag, nu geprijsd op $0.143; KOMA is een dog-type meme op de <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain, met een huidige circulerende marktkapitalisatie van $100 miljoen. De belangrijkste reden voor de toename is de notering van deze token futures op mainstream handelsplatformen;</p>
<h3 id="h3-Gangbare20Munten510325"><a name="Gangbare Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gangbare Munten</h3><p>-BTC oscilleert naar beneden, waarbij de psychologische barrière van $100.000 nog steeds de marktprestaties enige tijd onderdrukt. BTC ETF’s blijven grote instroom ontvangen en BTC is nog steeds geschikt voor kopen op middellange tot lange termijn;</p>
<p>-ETH is onder de $3.600 gezakt, ondanks de voortdurende grote nettostromen van ETH ETF-fondsen in de afgelopen twee weken, wordt de prestatie van ETH nog steeds beperkt door de algemene markt en heeft het geen onafhankelijke trend laten zien;</p>
<p>-Altcoins bevinden zich nog steeds binnen het aanpassingsbereik, waarbij de meeste van hen in de afgelopen maand meer dan 2-3 keer zijn gestegen. Momenteel is het een normale aanpassing en is het wachten op een nieuwe bodem een goede tijd om te kopen.</p>
<h2 id="h2-Macro20nieuws20Amerikaanse20aandelen20sloten20collectief20lager20de20markt20verwacht20over20het20algemeen20dat20de20Fed20de20rente20met202520basispunten20zal20verlagen301245"><a name="Macro nieuws: Amerikaanse aandelen sloten collectief lager, de markt verwacht over het algemeen dat de Fed de rente met 25 basispunten zal verlagen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro nieuws: Amerikaanse aandelen sloten collectief lager, de markt verwacht over het algemeen dat de Fed de rente met 25 basispunten zal verlagen.</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten gezamenlijk lager af, waarbij de S&amp;P 500-index met 0,30% daalde tot 6.034,91 punten; de Dow Jones Industrial Average daalde met 0,35% tot 44.247,83 punten; de Nasdaq-index daalde met 0,25% tot 19.687,24 punten. Het referentiepunt van de 10-jaars Treasury-rente is 4,22%, terwijl de 2-jaars Treasury-rente, die het meest gevoelig is voor de beleidsrente van de Federal Reserve, 4,15% bedraagt.</p>
<p>Investeerders richten zich op de aankomende Consumentenprijsindex (CPI) voor november, wat een van de belangrijkste economische rapporten van de Federal Reserve zal zijn vóór de rentevergadering volgende week. De algehele inflatie wordt verwacht licht te stijgen van 2,6% in oktober naar 2,7%. Hoewel de inflatie boven het streefcijfer van 2% van de Fed blijft, geloven handelaren dat er een grote kans is dat de Fed volgende week de rente verlaagt. De Federal Reserve Watch-tool van CME laat zien dat handelaren geloven dat er een kans van 86% is op een renteverlaging volgende week.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Ijslaag</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling. Alle investeringen brengen inherente risico's met zich mee; verstandige besluitvorming is essentieel.<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 er juridische actie worden ondernomen in verband met auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>