RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBoZXJzdGVsZGUgbmEgZWVuIHZhbCBvbmRlciBkZSAkNTlLIG9wIGtvcnRlIHRlcm1pam47IFN3YXJtIE1hcmtldHMgYmllZHQgZ2V0b2tlbmlzZWVyZCBnb3VkIGFhbiB2aWEgTkZUJ3M7IFpLc3luYyBUb2tlbiBkYWFsZGUgbWV0IDQwJSBuYSBkZSByZWxlYXNl

2024-06-25, 03:49

<p><img src="https://gimg2.gateimg.com/image/article/17192872981_18.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFs20hadden20een20nettostroom20van20een20week20BTC20daalde20op20korte20termijn20onder20de205900020en20het20Mt20Gox20terugbetalingsevenement20intensiveerde20de20marktturbulentie20Swarm20Markets20biedt20getokeniseerd20goud20aan20via20NFTs20De20ZKsynctoken20bleef20dalen20na20de20release20met20een20waardedaling20van2040978330"><a name="Crypto Dagelijkse Samenvatting: BTC ETF’s hadden een nettostroom van een week; BTC daalde op korte termijn onder de $59.000, en het Mt. Gox terugbetalingsevenement intensiveerde de marktturbulentie; Swarm Markets biedt getokeniseerd goud aan via NFT’s; De ZKsync-token bleef dalen na de release, met een waardedaling van 40%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF’s hadden een nettostroom van een week; BTC daalde op korte termijn onder de $59.000, en het Mt. Gox terugbetalingsevenement intensiveerde de marktturbulentie; Swarm Markets biedt getokeniseerd goud aan via NFT’s; De ZKsync-token bleef dalen na de release, met een waardedaling van 40%</h2><p>Allereerst gaan we de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor heeft Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 24 juni $90,4 miljoen aan uitstroom van fondsen ervaren; Ondertussen ervoer Fidelity Bitcoin spot ETF (FBTC) een uitstroom van $3.520, Bitwise Bitcoin spot ETF (BITB) een uitstroom van $8,2 miljoen, en ARK 21Shares Bitcoin spot ETF (ARKB) een uitstroom van $7,2 miljoen. Dit is de zevende opeenvolgende dag van nettouitstroom van Bitcoin spot ETF’s.</p>
<p>BTC daalde op korte termijn onder de $59.000, en het Mt. Gox terugbetalingsevenement intensiveerde de markt turbulentie</p>
<p>Op 24 juni, rond 20:30 UTC, daalde Bitcoin op korte termijn onder de $59.000, met een daling van 8,28% binnen 24 uur. Het totale bedrag van uitstaande posities op het hele netwerk overschreed $370 miljoen, voornamelijk geconcentreerd in longposities.</p>
<p>Vanuit technisch oogpunt is Bitcoin onlangs gedaald van boven de $70.000, waarbij een dubbel gepiekte bearish omkeerpatroon is gevormd. FalconX’s gegevens tonen echter aan dat de spot- en futureshandelsvolume van Bitcoin en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De handelsvolumes op gecentraliseerde beurzen liggen ver onder het historische hoogtepunt in maart, wat wijst op een afname van de betrokkenheid van beleggers of verkoopbereidheid, wat vaak kenmerkend is voor een ‘bear market trap’.</p>
<p>Eerder zag de cryptomarkt een aanzienlijke daling. Het bearish sentiment in de cryptomarkt werd steeds sterker en de failliete cryptobeurs Mt. Gox kondigde aan dat het volgende maand betalingen zou beginnen terugbetalen. Mt. Gox is van plan meer dan 140.000 Bitcoins terug te geven aan slachtoffers van de hackaanvallen van 2014. Na het nieuws daalde de prijs van Bitcoin kortstondig naar $60.723, een daling van meer dan 5% binnen 24 uur. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en andere belangrijke cryptocurrencies zijn ook getroffen, met de CoinDesk 20-index die meer dan 5% is gedaald.</p>
<p><strong>De regelgeving voor de stabiele munt MiCA staat op het punt te worden geïmplementeerd en Swarm Markets biedt getokeniseerd goud aan via NFT’s.</strong><br>Met nog iets meer dan een week te gaan voordat de regelgevende regels voor stablecoins van het Crypto Asset Market Regulation Agency (MiCA) van de Europese Unie van kracht worden, heeft het RWA-platform Swarm Markets een nieuwe manier gevonden om door activa gedekte tokens te verstrekken: het uitgeven van NFT’s gedekt door goud.</p>
<p>Swarm Markets, gevestigd in Berlijn, is van plan individuen in staat te stellen NFT’s aan te schaffen die fysiek goudbezit vertegenwoordigen. De goudstaven die deze getokeniseerde activa ondersteunen, worden opgeslagen in de kluis van Brink’s in Londen. Volgens de website van Swarm overtreft de totale waarde die in dit protocol is vergrendeld (TVL) $14,6 miljoen. Naast goud biedt het platform ook door token vermelde bedrijfsaandelen en Amerikaanse schatkistobligaties aan.</p>
<p>“NFT’s bieden ongekende transparantie voor token eigenaars. Door deze structuur kunnen mensen profiteren van de liquiditeit van DeFi terwijl ze gebruikmaken van de waarde en liquiditeit van de traditionele financiën (TradFi),” zei Timo Lehes, mede-oprichter van Swarm Markets. “Swarm heeft plannen om haar on-chain activa sector uit te breiden, en getokeniseerd goud is slechts de eerste stap in haar commodity reis.”</p>
<p>Swarm verklaarde dat zijn getokeniseerde goud niet te maken zou krijgen met de aankomende MiCA-regelgeving, omdat “deze regelgeving niet van toepassing is op unieke en onvervangbare crypto-assets, waaronder digitale kunst en verzamelitems,” volgens officiële MiCA-teksten. De EU heeft MiCA voor het eerst aangenomen in het midden van 2023 om de digitale activamarkt te reguleren en gerelateerde witwasactiviteiten uit te roeien, en men verwacht dat het tegen het einde van 2024 volledig van kracht zal zijn.</p>
<p>Na het leren over het ‘Ken uw klant’ (KYC) en ‘Anti-witwassen (AML) processen, kunnen gebruikers NFT’s op peer-to-peer basis uitwisselen via het gedecentraliseerde over-the-counter (dOTC) platform van Swarm.</p>
<p><strong>De ZKsync-token bleef dalen na zijn release, met een waardedaling van 40%.</strong><br>Op 17 juni ging de langverwachte ZKsync token ZK publiek, met een marktwaarde die op een gegeven moment meer dan $1 miljard bedroeg. In de eerste paar uur na de lancering steeg de marktwaarde van ZK kort. Op de dag van de release van de ZK token bereikte het aantal actieve adressen op het netwerk een historisch hoogtepunt van bijna 675.000.</p>
<p>Echter is de stijging van deze activiteit van korte duur. Op de tweede dag na de release van ZK-tokens daalde het handelsvolume op de keten met 37%, en op de derde dag bleef het verder dalen met 32%. Het 7-daagse voortschrijdend gemiddelde van actieve adressen op Zync Era vertoonde ook een vergelijkbare scherpe schommeling. Echter, slechts drie dagen later, verminderde het aantal actieve adressen met de helft. Deze scherpe daling suggereert dat de initiële stijging mogelijk is aangedreven door de plotselinge activiteit van luchtdruppelende mijnsites die werden gebruikt om tokens te verzamelen.</p>
<p>Op dit moment bedraagt de marktkapitalisatie van ZK ongeveer $600 miljoen, en de volledig verwaterde waardering is $3,4 miljard, een daling van 40% ten opzichte van de oorspronkelijke waardering.</p>
<p>Een week voor de release van ZK was het aantal nieuwe onafhankelijke adressen op de Zsync Era-keten relatief kalm, met een gemiddelde van ongeveer 7.000 nieuwe adressen per dag. Op de dag van de ZK-tokenrelease schoot dit aantal echter omhoog naar 18.000. Op de tweede dag na de eerste release steeg dit aantal opnieuw met meer dan 76%, tot 31.800. Tegen 19 juni was het aantal nieuwe onafhankelijke adressen gestegen tot 35.800.</p>
<h2 id="h2-Markttrends20Het20marktsentiment20is20extreem20laag20maar20belangrijke20cryptocurrencies20zijn20begonnen20met20herstellen201255"><a name="Markttrends: Het marktsentiment is extreem laag, maar belangrijke cryptocurrencies zijn begonnen met herstellen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Het marktsentiment is extreem laag, maar belangrijke cryptocurrencies zijn begonnen met herstellen.</h2><p>BTC daalde gisteravond kortstondig onder de $58.500, maar is sindsdien hersteld. Dit prijsniveau is een belangrijk ondersteuningsniveau en een herstel duidt op marktherkenning van dit ondersteuningsniveau. De Mt.Gox Exchange zal in juli ongeveer $10 miljard terugbetalen aan gebruikers. Dit evenement kan op korte termijn voor schommelingen op de markt zorgen, vooral met een toename van de omloop van BTC en ETH, en de impact ervan op de markt moet nauwlettend worden gevolgd.</p>
<p>ETH herstelde ook nadat het onder de $3.250 was gezakt. Net als BTC is dit prijsniveau ook een belangrijk ondersteuningsniveau, en het herstel van het marktsentiment kan de prijzen verder opdrijven.</p>
<p>Altcoins: Tijdens de daling van BTC en ETH toonden Altcoins een relatief sterke prestatie en herstelden ze als eerste. Dit kan te wijten zijn aan de uitstroom van marktfondsen uit mainstream munten, waarbij sommige fondsen naar relatief niche Altcoins stroomden op zoek naar hogere rendementen.</p>
<h3 id="h3-Macroeconomie156947"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>Amerikaanse aandelenmarkt daalt: Technologieleider Nvidia leidt de daling, waarbij mogelijk geld terugvloeit naar de cryptomarkt. De volatiliteit van Amerikaanse aandelen heeft doorgaans invloed op het risicobereidheid van wereldwijde investeerders, en de terugkeer van geld naar de cryptomarkt kan nieuwe investeringsmogelijkheden met zich meebrengen.</p>
<h3 id="h3-Markt20Hotspots484722"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>ETH-ecosysteem: LDO, MOG en andere tokens zijn gestegen en naar verwachting zal de markt zich blijven richten op het Ethereum-ecosysteemproject als de belangrijkste hype vóór de goedkeuring van de Ethereum spot ETF in juli. Beleggers kunnen zich richten op de trends van deze projecten.</p>
<p>De AI-sector zag een aanzienlijke toename van tokens zoals FET, AGIX, OCEAN en PHB. De AI-sector loopt altijd voor op de markt wat betreft historische markttrends, en AI blijft een van de meest gangbare verhalen in deze ronde van markttrends. FET, AGIX en OCEAN zullen op 15 juli tokens samenvoegen, en de samengevoegde tokens zullen ASI zijn. Dit evenement kan verdere marktvolatiliteit en speculatie veroorzaken, en investeerders moeten vooruit plannen.</p>
<p>Nieuwe muntsector: LISTA steeg alleen, en het Lista-project kondigde gisteren het begin aan van een nieuwe ronde van mining. LISTA/ <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> mining bereikte een geannualiseerd tarief van 245%. Hoogrenderende mijnbouwprojecten kunnen meestal een grote hoeveelheid kapitaalinstroom aantrekken en op korte termijn aanzienlijke groei ervaren.</p>
<p>Blast airdrop: Het Ethereum Layer2-project BLAST zal om 12:00 (UTC) beginnen met een tokenairdrop. Airdrop-activiteiten brengen meestal korte-termijn markthevigheden met zich mee, wat tot schommelingen in handelsvolume en prijzen kan leiden.</p>
<p>Hoewel het marktsentiment traag is, zijn Altcoins al als eerste hersteld, en de bewegingen in het ETH-ecosysteem en de AI-sector zijn het waard om op te letten. Er zijn nog steeds veel potentiële investeringsmogelijkheden in de crypto-industrie. Investeerders moeten de markttrends nauwlettend volgen en hun bezittingen redelijk toewijzen om toekomstige schommelingen het hoofd te bieden.</p>
<h2 id="h2-Macro20Technologieaandelen20trekken20zich20afwisselend20terug20de20SampP2050020en20Nasdaq20daalden20en20de20Dow20steeg20Aziatische20aandelenmarkten20worden20onderdrukt20door20de20prestaties20van20technologieaandelen20terwijl20de20daling20van20de20aandelenprijs20van20Nvidia20van20invloed20is20op20het20marktsentiment677013"><a name="Macro: Technologieaandelen trekken zich afwisselend terug, de S&amp;P 500 en Nasdaq daalden, en de Dow steeg; Aziatische aandelenmarkten worden onderdrukt door de prestaties van technologieaandelen, terwijl de daling van de aandelenprijs van Nvidia van invloed is op het marktsentiment." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Technologieaandelen trekken zich afwisselend terug, de S&amp;P 500 en Nasdaq daalden, en de Dow steeg; Aziatische aandelenmarkten worden onderdrukt door de prestaties van technologieaandelen, terwijl de daling van de aandelenprijs van Nvidia van invloed is op het marktsentiment.</h2><p>Op maandag klom de Dow Jones-index naar een hoogste niveau in een maand, terwijl de Nasdaq-index meer dan 1% daalde. Omdat investeerders zich terugtrokken uit aandelen gerelateerd aan kunstmatige intelligentie en in plaats daarvan investeerden in enkele onderpresterende aandelen, in de hoop dat de Federal Reserve dit jaar de rente zal verlagen.</p>
<p>Wat betreft specifieke indices steeg de Dow Jones-index met 0,66%; De S&amp;P 500-index daalde met 0,31%; De Nasdaq-index daalde met 1,09%. Hoewel technologische aandelen zich terugtrokken, waardoor de S&amp;P 500-index en de Nasdaq-index lager sloten, behaalden 9 van de 11 belangrijkste bedrijfssectoren van de S&amp;P 500-index winst.</p>
<p>De belangrijkste focus van investeerders deze week is het rapport over de persoonlijke consumptie-uitgaven (PCE) prijsindex, dat op vrijdag wordt vrijgegeven en de voorkeursindicator is voor de Federal Reserve om de inflatie te meten. Verwacht wordt dat het rapport enige verlichting van de prijsdruk zal laten zien. Daarnaast worden deze week ook gegevens vrijgegeven over duurzame goederenorders, wekelijkse werkloosheidsaanvragen, het definitieve BBP voor het eerste kwartaal en de jaarlijkse herstructurering van de Russell-index. Ook zullen er deze week verschillende kwartaalwinstrapporten worden vrijgegeven.</p>
<p>Op donderdag zal president Joe Biden in Atlanta in debat gaan met zijn Republikeinse tegenstander Donald Trump, wat mogelijk invloed kan hebben op de verkiezingen in november, die volgens opiniepeilingen momenteel gelijk op gaan.</p>
<p>Op 25 juni, in de vroege handelssessie van de Aziatische markt, leek de golf van winstneming in grote Amerikaanse technologie- en kunstmatige intelligentie-aandelen meer uitgesproken. Dit kan de sentiment van investeerders en risicobereidheid op de Aziatische markt op dinsdag onderdrukken, zelfs als het overschakelen naar getroffen sectoren het effect gedeeltelijk kan compenseren. Voorafgaand aan de publicatie van Amerikaanse inflatiegegevens op vrijdag, kan de markt voorzichtig blijven, vooral omdat vrijdag ook de laatste handelsdag van het kwartaal is.</p>
<p>De MSCI Asia Pacific Stock Index steeg met 0,3% en is in de afgelopen drie handelsdagen met 1,4% gedaald. De Nikkei-index in Japan steeg met 0,5%. De Taiwanese aandelenmarkt daalde met 0,4%. Chinese blue chip-aandelen stegen licht met 0,1%, terwijl de Hang Seng Index in Hong Kong met 0,9% steeg.</p>
<p>Wat betreft valuta, toonden de notulen van de laatste vergadering van de Bank of Japan op maandag aan dat Japanse beleidsmakers de mogelijkheid van recente renteverhogingen bespraken, waarbij iemand opriep om ‘niet te lang uit te stellen’ om de inflatie te helpen verlagen. De Japanse yen waardeerde maandag licht, maar de omvang was nog steeds dicht bij 160 yen in vergelijking met de Amerikaanse dollar.</p>
<p>Op het gebied van grondstoffen zijn de olieprijzen relatief stabiel gebleven. De prijs van Brent ruwe olie-futures bleef op $85,95 per vat, terwijl de prijs van Amerikaanse ruwe olie-futures bijna onveranderd bleef op $81,60 per vat.</p>
<p>De prijs van goud daalde met 0,3% tot $2.325,52 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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor 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 schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>