RGFnZWxpamtzIG5pZXV3cyB8IEhLIGtldXJkZSBFVEggZW4gQlRDIFNwb3QgRVRGJ3MgZ29lZDsgRGUgYm9kZW1wcmlqcyB2YW4gJ0JvcmVkIEFwZScgTkZUIGRhYWxkZSB0b3Qgb25kZXIgZWVuIG5pZXV3IGRpZXB0ZXB1bnQ7IEdhbWVGaSBJbGx1dml1bSB6YWwgJDI1TSBhYW4gdG9rZW5sdWNodGRyb3BwaW5ncyBsYW5jZXJlbg==

2024-04-16, 03:43

<p><img src="https://gimg2.gateimg.com/image/article/171323895416.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20De20nieuwste20goedgekeurde20ETH20en20BTC20spot20ETFs20in20HK20De20bodemprijs20van20Bored20Ape20NFT20is20gedaald20tot20een20nieuw20dieptepunt20sinds20202120GameFi20Illuvium20zal202520miljoen20aan20tokenuitdelingen20lanceren484938"><a name="Crypto Dagelijks Overzicht: De nieuwste goedgekeurde ETH en BTC spot ETF’s in HK; De bodemprijs van “Bored Ape” NFT is gedaald tot een nieuw dieptepunt sinds 2021; GameFi Illuvium zal $25 miljoen aan token-uitdelingen lanceren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: De nieuwste goedgekeurde ETH en BTC spot ETF’s in HK; De bodemprijs van “Bored Ape” NFT is gedaald tot een nieuw dieptepunt sinds 2021; GameFi Illuvium zal $25 miljoen aan token-uitdelingen lanceren</h2><p>Eerst gaan we de handelsactiviteiten van onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor bedroeg de uitstroom van Grayscale’s GBTC-fonds op 15 april $110,1 miljoen; De voortdurende uitstroom van Bitcoin-spot-ETF-fondsen in de afgelopen dagen is tot op zekere hoogte een voorzichtige reactie van de markt.</p>
<p>In de afgelopen drie maanden is de cumulatieve nettostroom van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s in de Verenigde Staten meer dan $12.5 miljard geweest, en de totale netto-activawaarde heeft $58 miljard overschreden. Nu is de aandacht van de markt ook gericht op de trend van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETFs.</p>
<p>Hongkong is de nieuwste regio geworden die BTC ETF spot ETF’s goedkeurt. Jiashi International, Boshi Fund en Huaxia Fund (Hong Kong) hebben achtereenvolgens aangekondigd dat ze zijn goedgekeurd door de Hong Kong Securities Regulatory Commission om virtuele vermogensbeheerdiensten aan beleggers te verstrekken en van plan zijn ETF-producten uit te geven die kunnen investeren in BTC spot en ETH spot.</p>
<p>Hoewel de omvang van de Hong Kong ETF-markt relatief klein is, hebben beleggers nog steeds een positieve houding ten opzichte van de goedkeuring van Hong Kong Bitcoin spot ETF’s en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot ETF’s, waardoor een groot aantal kopers toetreedt. ETH wordt momenteel verhandeld op $3,086.99, wat waarschijnlijk zal herstellen na enkele opeenvolgende dagen van terugtrekkingen.</p>
<p>In vergelijking met het bloeiende algemene ecosysteem van de crypto-markt de laatste tijd, lijkt de NFT-markt vrij desolaat, zoals blijkt uit de Bored Ape Yacht Club-serie NFT’s die drie jaar geleden zijn uitgebracht en die door veel beroemdheden zijn gepromoot. Hoewel de hele NFT-markt gedurende een aanzienlijke periode traag is geweest, presteert BAYC vaak sterk. Het wordt beschouwd als een van de meest succesvolle verhalen op de markt, met een actieve gemeenschap en een populaire iteratieserie.</p>
<p>Op basis van historische gegevens is volgens CryptoSlam BAYC de best gerangschikte NFT-serie op de verzamelmarkt qua verkoop, met verkopen die meer dan $3 miljard overtreffen.</p>
<p>Vanaf maandag is de laagste prijs van Bored Ape NFT gedaald naar 10,9 ETH (ongeveer $34.000). Volgens gegevens van de NFT-datawebsite is de bodemprijs van de NFT sinds begin augustus 2021, toen het 9,5 ETH was, nooit zo laag geweest.</p>
<p>BAYC dat door enkele beroemdheden is verworven, werd later verkocht voor een klein deel van de oorspronkelijke prijs. Volgens NFT Price Floor-gegevens is de huidige bodemprijs meer dan 90% lager dan de historische hoogte van BAYC van 128 ETHs (momenteel ongeveer $395.000) die in april 2022 werd bereikt. Yuga Labs, oprichter van de Bored Ape Yacht Club (BAYC) serie, weigerde hierop te reageren.</p>
<p>Illuvium heeft de lancering van een token airdrop-campagne aangekondigd, waarbij in totaal 250.000 ILV-tokens worden aangeboden, wat ongeveer $25 miljoen waard is. Daarvan zullen 50.000 ILV’s worden gebruikt voor loyaliteitsairdrops, en de overige 200.000 ILV’s zullen worden verdeeld tijdens de 6-maanden durende Play-to-Airdrop-activiteit.</p>
<p>De activiteit vereist dat gebruikers actief deelnemen en interactie hebben in de spellen van Illuvium, waaronder arena-gevechten, virtuele wereldverkenning, landontwikkeling, NFT-verzameling en -handel, enz. De activiteitspunten bepalen het aantal airdropped ILVs. De eerste batch van 20.000 ILVs wordt tijdens de bètatestfase gedistribueerd, en de resterende 180.000 ILVs worden geleidelijk airdropped binnen 5 maanden na de officiële lancering van de Beta mainnet.</p>
<p>Loyalty airdrops zullen gebruikers belonen die actief hebben deelgenomen aan het Illuvium-ecosysteem in de afgelopen drie jaar, waaronder het inzetten van ILV-tokens, het verschaffen van LP-liquiditeit, het kopen van virtueel land, het verhandelen van NFT’s, enz., en zijn gepland om te worden gedistribueerd in Q2 2024. Illuvium heeft een momentopname gemaakt op 14 april.</p>
<p>Illuvium is een open-wereld RPG 3A-niveau spel gebouwd op Ethereum’s L2 <a href="/price/immutablex-imx" rel="nofollow noopener noreferrer" target="_blank">ImmutableX</a>. De studio heeft als doel het bouwen van het eerste interoperabele blockchain game (IBG) universum ter wereld, inclusief open wereld verkenningsspellen, industriële stad bouwspellen en automatische gevechtsspellen, die allemaal op de Ethereum blockchain worden gespeeld. De private beta 4 (PB4) begint op 30 april en het openbare beta testnet begint op 28 mei.</p>
<h2 id="h2-Markttrends20De20markt20daalt20met20BTC20halvering20in20minder20dan20520dagen783979"><a name="Markttrends: De markt daalt, met BTC halvering in minder dan 5 dagen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt daalt, met BTC halvering in minder dan 5 dagen</h2><p>De markt bleef dalen na een kortstondig herstel gisteren, minder dan 5 dagen na de halvering van Bitcoin. Met betrekking tot macro-economie heeft de Amerikaanse aandelenmarkt een scherpe daling doorgemaakt. De detailhandelsgegevens in maart overtroffen de verwachtingen en de marktverwachting voor de eerste renteverlaging door de Federal Reserve werd aanzienlijk vertraagd.</p>
<h3 id="h3-Marktplaats20Hotspots265936"><a name="Marktplaats Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Marktplaats Hotspots:</h3><p>Fan coinsector: Tokens in fan coinsectoren zoals JUV, CITY, BAR en PSG zijn gestegen. De Europese beker voetbalwedstrijd gaat bijna beginnen en de markt hypet gerelateerde concepttokens op, wat de aandacht en jacht van investeerders heeft aangetrokken.</p>
<p>Hong Kong concept tokens: ACH, PHB en andere Hong Kong concept tokens zijn gestegen, wat te danken is aan het nieuws dat Hong Kong binnenkort Bitcoin en Ethereum spot ETF’s zal gaan aannemen.</p>
<p>Volgens Bloomberg wordt verwacht dat de instroom van Bitcoin spot ETF’s in Hong Kong $500 miljoen zal bereiken, wat ook de prestaties van Hong Kong concepttokens stimuleert.</p>
<p>De prestaties van andere anti-vallende munten: In een dalende markt presteert TON relatief goed, terwijl andere vergelijkbare munten ONDO en PENDLE bevatten. TON is onlangs een populaire token geworden en het IPO-nieuws van Telegram verbetert zijn fundamenten aanzienlijk. Als toonaangevende token in de RWA-sector presteert ONDO ook relatief sterk qua prijs. De totale waarde vergrendeld (TVL) van PENDLE blijft groeien en nadert momenteel $4,5 miljard, met een meer dan 7-voudige stijging sinds het begin van dit jaar.</p>
<p>Samengevat blijft de markt dalen, maar sommige specifieke sectoren en tokens presteren nog steeds sterk. Investeerders moeten de markttrends nauwlettend volgen en hun investeringsstrategieën dienovereenkomstig aanpassen.</p>
<h2 id="h2-Macro20De20escalerende20gespannen20politieke20situatie20onderdrukt20de20risicobereidheid20wereldwijde20aandelenmarkten20blijven20voorzichtig20en20goud20en20olieprijzen20stijgen929390"><a name="Macro: De escalerende gespannen politieke situatie onderdrukt de risicobereidheid, wereldwijde aandelenmarkten blijven voorzichtig, en goud- en olieprijzen stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De escalerende gespannen politieke situatie onderdrukt de risicobereidheid, wereldwijde aandelenmarkten blijven voorzichtig, en goud- en olieprijzen stijgen</h2><p>De Amerikaanse aandelenmarkt sloot maandag fors lager, voornamelijk omdat de markt zich zorgen maakte over de toenemende spanningen tussen Iran en Israël, terwijl het rendement van Amerikaanse schatkistpapier sterk steeg en het marktsentiment dempte.</p>
<p>Hoewel het sterke detailhandelsverkooprapport in de vroege sessie het marktsentiment had versterkt, veroorzaakten de daaropvolgende scherpe stijging in het rendement van Amerikaanse schatkistobligaties en de groeiende geopolitieke spanningen tussen Iran en Israël bezorgdheid op de markt.</p>
<p>Wat betreft de drie belangrijkste indices daalde de Dow Jones Industrial Average met 0,65%, daalde de S&amp;P 500-index met 1,2% en daalde de Nasdaq-index met 1,79%. De aandelenmarkt heeft recentelijk zwak gepresteerd, waarbij de S&amp;P 500-index twee opeenvolgende weken daalde, wat de grootste wekelijkse procentuele daling markeerde sinds oktober vorig jaar. Dit is voornamelijk te wijten aan investeerders die hun verwachtingen voor de timing en omvang van de renteverlagingen van de Federal Reserve uitstellen.</p>
<p>In het vorige week gepubliceerde rapport werd benadrukt dat de inflatie hoger blijft dan de marktverwachtingen, wat heeft geleid tot een aanzienlijke vermindering van de renteverlagingen dit jaar. Op dit moment verwachten handelaren een renteverlaging van 45 basispunten dit jaar, ver beneden de verwachte 160 basispunten aan het begin van het jaar. Volgens gegevens van de FedWatch tool van de Chishang Exchange verwacht de markt momenteel dat de renteverlagingen in september zullen beginnen in plaats van juni.</p>
<p>Ook Aziatische aandelenmarkten kenden op dinsdag een daling, waarbij de Amerikaanse dollar steeg naar een hoog niveau van meer dan vijf maanden. Dit is voornamelijk te wijten aan sterkere dan verwachte detailhandelsverkopen in de Verenigde Staten in maart, waardoor de marktverwachtingen worden versterkt dat de Federal Reserve geen haast heeft om actie te ondernemen. Tegelijkertijd groeide de Chinese economie met 5,3% op jaarbasis in het eerste kwartaal, wat de verwachtingen van analisten overtrof.</p>
<p>Het rendement van 10-jarige staatsobligaties in Azië was 4,610%, wat op maandag is gestegen naar een vijf maanden hoogte van 4,663%. De stijging van dit rendement heeft de Amerikaanse dollar omhooggedreven en de Japanse yen in de buurt gehouden van het 34-jarige dieptepunt dat het de afgelopen dagen heeft bereikt.</p>
<p>De Japanse minister van Financiën Junichi Suzuki verklaarde dinsdag dat hij de wisselkoerstrend nauwlettend in de gaten houdt nadat de Amerikaanse dollar in 34 jaar tijd tot een nieuw hoogtepunt is gestegen en indien nodig ‘grondige tegenmaatregelen’ zal nemen.</p>
<p>Met betrekking tot grondstoffen heeft de voortdurende intensivering van geopolitieke spanningen in het Midden-Oosten het risicobereidheid van beleggers onderdrukt en de prijzen van goud en olie verhoogd.</p>
<p>Amerikaanse ruwe olie steeg met 0,76% naar $86,06 per vat, terwijl Brent ruwe olie met 0,69% steeg naar $90,72.</p>
<p>De laatste prijs van spotgoud is $2.381,50 per ounce.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Sherry S. &amp; Glazuur</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 op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>