RGFnZWxpamtzIG5pZXV3cyB8IFNwb3QgRXRoZXJldW0gRVRGIGVpbmRlbGlqayBnb2VkZ2VrZXVyZDsgT25kbydzIFVTRFkgd29yZHQgZ2VsYW5jZWVyZCBpbiBDb3Ntb3MtZWNvc3lzdGVlbTsgSEsgemFsIEF6acOrJ3MgZWVyc3RlIG9tZ2VrZWVyZGUgQml0Y29pbiBFVEYncyBsYW5jZXJlbg==

2024-07-23, 03:25

<p><img src="https://gimg2.gateimg.com/image/article/17217050141_18.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20De20spot20Ethereum20ETF20heeft20definitieve20goedkeuring20ontvangen20en20zal20binnenkort20beginnen20met20handelen20Ondos20USDY20is20gelanceerd20in20het20Cosmosecosysteem20Hong20Kong20zal20de20eerste20omgekeerde20Bitcoin20ETFs20in20Azi20lanceren822687"><a name="Crypto Dagelijks Overzicht: De spot Ethereum ETF heeft definitieve goedkeuring ontvangen en zal binnenkort beginnen met handelen; Ondo’s USDY is gelanceerd in het Cosmos-ecosysteem; Hong Kong zal de eerste omgekeerde Bitcoin ETF’s in Azië lanceren." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: De spot <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF heeft definitieve goedkeuring ontvangen en zal binnenkort beginnen met handelen; Ondo’s USDY is gelanceerd in het Cosmos-ecosysteem; Hong Kong zal de eerste omgekeerde <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s in Azië lanceren.</h2><p>Eerst gaan we de handelsactiviteit van nader onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor ontving de Fidelity Bitcoin Spot ETF (FBTC) op 22 juli $23,7 miljoen aan instroom, ontving de BlackRock Bitcoin Spot ETF (IBIT) $523,3 miljoen aan instroom en ontving de VanEck Bitcoin Spot ETF (HODL) $38,4 miljoen aan uitstroom.</p>
<p><strong>De plek <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF heeft uiteindelijke goedkeuring ontvangen en staat op het punt om te beginnen met handelen</strong></p>
<p>Na wekenlang wijzigen van registratieverklaringen zijn spot Ethereum ETF’s van meerdere exchange-traded funds goedgekeurd en zullen ze dinsdag beginnen met handelen.</p>
<p>Op maandagmiddag heeft de Amerikaanse Securities and Exchange Commission (SEC) registratieaanvragen goedgekeurd voor 21Shares, Bitwise, BlackRock, Fidelity, Franklin Templeton, VanEck en Invesco Galaxy. Ook de registratieformulieren voor de Grayscale Ethereum Trust en de Ethereum Mini Trust zijn op dezelfde dag goedgekeurd.</p>
<p>De spot Bitcoin ETF werd eerder dit jaar goedgekeurd en leverde miljarden dollars aan rendement op. Eric Balchunas, een senior ETF-analist bij Bloomberg, gelooft dat de vraag naar Ethereum ETF’s mogelijk lager zal zijn dan die naar Bitcoin ETF’s, die 10% tot 15% van de Bitcoin-productactiva zullen ontvangen, of een waarde van $5 miljard tot $8 miljard, wat ook zeer objectief is.</p>
<p>Cynthia Lo Bessette, Hoofd Digital Asset Management bij Fidelity, verklaarde dat de spot Ethereum ETF van het bedrijf beleggers zal voorzien van “doordacht index- en productontwerp ondersteund door toegewijde operationele en handelsteams” voor veiliger toegang tot Ethereum. Ze voegde eraan toe: ‘Dit weerspiegelt de lange geschiedenis en toewijding van Fidelity om te voldoen aan de voortdurend veranderende behoeften van klanten.’</p>
<p>Na de goedkeuring van de spot Bitcoin ETF begon de beurs na te denken over handelsopties voor deze producten, maar heeft nog geen goedkeuring van toezichthouders ontvangen. De SEC stelde vragen bij de stakingdienst van ETH en bepaalde dat Ethereum ETF’s geen staking bevatten. Analisten zijn echter van mening dat bedrijven in de toekomst mogelijk staking zullen opnemen in hun ETF-producten.</p>
<p><strong>Ondo’s USDY wordt native gelanceerd in het Cosmos-ecosysteem</strong></p>
<p>Het Ondo-team heeft Ondo US dollar yield (USDY) gelanceerd op Cosmos. USDY is een getokeniseerde nota, een stablecoin-product dat wordt gegarandeerd door kortlopende Amerikaanse schatkistobligaties en huidige deposito’s van Amerikaanse banken. Het is de eerste originele stablecoin van de Amerikaanse dollar in het Cosmos-ecosysteem. Met deze stap wordt USDY geïntroduceerd in meer dan 90 op applicaties gerichte Cosmos-blockchains.</p>
<p>USDY stelt wereldwijde (niet-Amerikaanse) individuele en institutionele beleggers in staat rendementen te ontvangen, met een totale waarde van meer dan $300 miljoen die momenteel vergrendeld is op meerdere blockchains. USDY zal speciaal worden aangenomen op Injective. Helix, een derivatenbeurs gebaseerd op Injective, zal USDY lanceren als onderpand voor spot-activa en eeuwige markten. Dit stelt gebruikers in staat om voor het eerst winst te maken met USDY tijdens het handelen op de keten. Bovendien zal een ander protocol op Injective, Hydro, USDY opnemen in zijn gestructureerde activa, waardoor gebruikers on-chain winsten kunnen behalen. Volgens de gegevens van CoinGecko overstijgt de marktwaarde van USDY $222 miljoen.</p>
<p>Noble is een speciaal gebouwde blockchain die bekend staat als het native asset issuance netwerk voor Circle’s USDC stablecoin in het Cosmos ecosysteem. Sinds de eerste lancering in september 2023 is de native uitgifte van USDC op Noble meer dan $243 miljoen.</p>
<p>Hoewel USDY werd gelanceerd via het Noble blockchain, zijn er verschillende andere Cosmos chains en DeFi-projecten, waaronder Injective, die het hebben overgenomen. <a href="/price/osmosis-osmo" rel="nofollow noopener noreferrer" target="_blank">Osmose</a>, Kujira en Pyth zullen ook gebruik maken van USDY.</p>
<p><strong>Hong Kong zal Azië’s eerste omgekeerde Bitcoin ETF’s lanceren</strong></p>
<p>Op 23 juli zal Hong Kong het eerste omgekeerde Bitcoin futuresproduct van Azië lanceren - CSOP Bitcoin Futures Daily (-1x) Reverse Product.</p>
<p>Een van China’s grootste vermogensbeheermaatschappijen, CSOP Asset Management Limited, lanceerde een nieuw exchange traded fund (ETF). Voorafgaand hieraan werd de CSOP Bitcoin Futures ETF met succes gelanceerd in december 2022, waarmee het bedrijf zijn uitbreiding in de regio Azië-Pacific voortzette. Het nieuwe Bitcoin ETF heeft tot doel beleggers een manier te bieden om te profiteren van de daling van de Bitcoin-prijzen.</p>
<p>Het CSOP Bitcoin Futures Daily (-1x) Reverse Product heeft als doel beleggingsresultaten te bieden die nauw overeenkomen met de dagelijkse omgekeerde prestaties van de S&amp;P Bitcoin Futures Index. Dit omgekeerde product bereikt dit doel door middel van een op futures gebaseerde replicatiestrategie, waarbij rechtstreeks wordt geïnvesteerd in Bitcoin-futures van de spotmaand van de Chicago Mercantile Exchange.</p>
<p>Volgens Southern Dongying zal het product op 22 juli worden genoteerd aan de Hong Kong Stock Exchange (HKEX) tegen een prijs van ongeveer HKD 7,8 per eenheid. Dit weerspiegelt ook de complexiteit van wereldwijde crypto-financiële producten.</p>
<h2 id="h2-Markttrends20ETH20ETF20officieel20goedgekeurd20Memesector20presteert20nog20steeds20goed983416"><a name="Markttrends: ETH ETF officieel goedgekeurd, Meme-sector presteert nog steeds goed" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: ETH ETF officieel goedgekeurd, Meme-sector presteert nog steeds goed</h2><p>BTC: BTC-prijzen consolideren horizontaal op hoge niveaus, en spot ETF’s blijven netto instroom ervaren, maar de omvang van de instroom is relatief klein. Naarmate BTC-prijzen stijgen, verzwakt de marktenthousiasme voor fondsen.</p>
<p>ETH: ETH liet een relatief sterke prestatie zien, met een sterke opwaartse trend in prijs. Vanochtend werd de ETH ETF officieel goedgekeurd en zal morgen beginnen met handelen, wat het marktsentiment verder zal versterken.</p>
<p>Altcoins: De meeste Altcoins hebben prijsdalingen meegemaakt en de markt mist nieuwe hotspots. Behalve Meme coins hebben andere sectoren een matige prestatie laten zien.</p>
<h3 id="h3-Gegevensindicatoren9676"><a name="Gegevensindicatoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevensindicatoren</h3><p>AHR999-index: De AHR999-index van vandaag staat op 0.93 en de markt is de bodemzone gepasseerd, maar het is nog steeds geschikt voor reguliere investeringen.</p>
<p>Angst Gier Index: De huidige Angst Gier Index is 71. De marktsentiment is al twee opeenvolgende dagen hebzuchtig geweest, met optimistisch beleggerssentiment.</p>
<h3 id="h3-Macroeconomie472296"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>Prestaties van Amerikaanse aandelen: de drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger, herstellend van oververkocht. Toonaangevende bedrijven in het AI-veld, NVIDIA en Tesla, zijn beide gestegen, wat heeft bijgedragen aan de algehele stijging van de technologiesector. Musk heeft xAI sterk gepromoot op Twitter, waardoor de marktaandacht voor AI verder is toegenomen.</p>
<h3 id="h3-Markt20hotspots525549"><a name="Markt hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots:</h3><p><strong>De Trump politiek concept token en de op katten geïnspireerde Meme-munten in de Meme-sector presteerden goed met goede winsten:</strong><br>DMAGA, DELON: Nadat Musk zijn Twitter-avatar verving door Laser Eye, stegen gerelateerde concepttokens zoals DMAGA en DELON. Volgens feedback van de community worden de uitgiftadressen van deze tokens verdacht van voorbereiding door een muizenmagazijn.</p>
<p>MEW en MANEKI: Katten-thema Meme munten hebben uitstekend gepresteerd. MEW brak door een historisch hoogtepunt en kende een kortetermijndaling, terwijl MANEKI, dat het beeld van een geldzoekende kat vertegenwoordigt, bijna 50% steeg binnen één dag.</p>
<p><strong>Ton Ecosysteem:</strong><br>Pixelverse: Het officiële Twitter-account van het populaire spel Pixelverse op de Ton-keten is verbannen, wat heeft geleid tot een aanzienlijke daling van meer dan 60% in PIXFI binnen een dag.</p>
<p>Honden: Het officiële Twitter-account is ook verbannen. Dit heeft onzekerheid veroorzaakt over de airdrop van Ton’s populaire ecosysteemprojecten en de markt mag niet langer betalen.</p>
<h3 id="h3-Samenvattend583435"><a name="Samenvattend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Samenvattend</h3><p>Het huidige marktsentiment is optimistisch, maar voorzichtigheid is geboden voor het mogelijke risico van een terugval als gevolg van zijwaarts handelen op hoog niveau. De goedkeuring van ETH ETF is belangrijk positief nieuws dat het marktsentiment op korte termijn verder zal stimuleren. De Altcoin-sector heeft echter zwakke prestaties laten zien, en Meme coin blijft de best presterende tokensector in deze ronde van de markt.</p>
<h2 id="h2-Macro20Beleggers20keren20terug20naar20largecap20aandelen20Wall20Street20sluit20hoger20Chipaandelen20herstellen20Aziatische20aandelenmarkten20beindigen20de20voortdurende20neerwaartse20trend531783"><a name="Macro: Beleggers keren terug naar large-cap aandelen, Wall Street sluit hoger; Chipaandelen herstellen, Aziatische aandelenmarkten beëindigen de voortdurende neerwaartse trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Beleggers keren terug naar large-cap aandelen, Wall Street sluit hoger; Chipaandelen herstellen, Aziatische aandelenmarkten beëindigen de voortdurende neerwaartse trend</h2><p>Op maandag 22 juli stroomden investeerders terug naar grote groeiaandelen, waardoor de drie belangrijkste referentie-indexen van Wall Street hoger sloten. De S&amp;P 500 en Nasdaq Composite Index zijn aanzienlijk hersteld van hun eerdere trage prestaties. De Dow Jones Industrial Average keerde ook succesvol terug naar de positieve zone en beëindigde zijn twee opeenvolgende handelsdagen van daling sinds het raken van een historisch hoogtepunt vorige week woensdag.</p>
<p>De specifieke indexprestaties zijn als volgt: de Dow Jones Industrial Average steeg met 0,32%, de S&amp;P steeg met 1,08% en de Nasdaq steeg met 1,58%.</p>
<p>Het herstel van aandelen met een grote marktkapitalisatie is de belangrijkste drijvende kracht achter dit marktherstel. De aandelenkoersen van grote bedrijven zoals Alphabet, Meta Platforms en Tesla stegen met 2,2% tot 5,1%.</p>
<p>De politieke situatie blijft invloed hebben op de markt. Het vertrek van Biden kan investeerders aanzetten om hun posities te liquideren omdat ze wedden dat de overwinning van de Republikeinse Trump de fiscale en inflatoire druk in de Verenigde Staten zal vergroten. Ondertussen zijn sommige analisten van mening dat als er een splitsing is in de volgende regering, de markt daarvan kan profiteren.</p>
<p>Op 23 juli herstelden de Aziatische aandelenmarkten zich van een maand dieptepunt en beëindigde de Taiwanese aandelenmarkt zijn vijfdaagse neerwaartse trend. Het herstel van de Wall Street aandelenmarkt zorgde ervoor dat de aandelen van de halfgeleidersector stegen. De Shanghai en Shenzhen 300 Index steeg met 0,55%, terwijl de Nikkei Index in Japan met 1,6% steeg vanwege de stabilisatie van de chipaandelen.</p>
<p>De benchmark TWII-index in Taiwan steeg ongeveer 1,7% bij de opening van de handel, waarbij chipfabrikant TSMC met 2% steeg. Eerder, als gevolg van de dubbelzinnige houding van de Amerikaanse presidentskandidaat Donald Trump tijdens een interview ten opzichte van het beschermen van Taiwan en zijn chipindustrie, verdampte de marktwaarde van TSMC vorige week met ongeveer $100 miljard.</p>
<p>De Zuid-Koreaanse chipfabrikant Samsung herstelde ook omdat handelaren zich richtten op de sterke vraag en politieke risico’s negeerden.</p>
<p>Wat betreft de valutamarkt verwacht de markt dat de Verenigde Staten dit jaar twee keer de rente zal verlagen, wat begint te zorgen voor druk op de Amerikaanse dollar. Ondanks de onzekerheid van de Amerikaanse presidentsverkiezingen die een significante daling van de Amerikaanse dollar voorkomt, bleef de wisselkoers euro/dollar stabiel op 1,089 op dinsdag, terwijl de wisselkoers yen/dollar licht steeg naar 156,8. De Australische dollar daalde naar een drie weken laagte tegenover de Amerikaanse dollar, en de Nieuw-Zeelandse dollar daalde naar een bijna drie maanden laagte van $0,5966 ten opzichte van de Amerikaanse dollar, maar analisten verwachten dat de Australische en Nieuw-Zeelandse dollars binnenkort zullen herstellen.</p>
<p>Met betrekking tot de grondstoffenmarkt heeft China maandag onverwacht de rente verlaagd, in combinatie met lagere dan verwachte economische groeigegevens vorige week, wat zorgen heeft gewekt over het economisch vooruitzicht. De prijzen van Dalian ijzerertsfutures daalden naar het laagste punt sinds april en de koperprijzen in Shanghai daalden dienovereenkomstig.</p>
<p>Brent ruwe olie termijncontracten bereikten ‘s nachts een dieptepunt van een maand, met de laatste prijs op $82.59 per vat.</p>
<p>Nu de Amerikaanse dollar sterker werd en handelaren deze week wachten op meer Amerikaanse economische gegevens en opmerkingen van functionarissen van de Federal Reserve, daalden de goudprijzen op maandag naar hun laagste punt in meer dan een week. Spot goud daalde met 0,2% tot $2394,18 per ounce. De afwikkelingsprijs van Amerikaanse goud futures daalde met 0,1% tot $2.394,70 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 beleggingsadvies.<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>