RGFnZWxpamtzIG5pZXV3cyB8IEhLIEV0aGVyZXVtIEVURiB6YWwgd29yZGVuIHZlcmhhbmRlbGQ7IFdMRC1vcHJpY2h0ZXIgb250bW9ldHRlIE1hbGVpc2lzY2hlIGxlaWRlcnMgb20gZGUgcmVnZXJpbmdzcmVsYXRpZXMgdGUgdmVyc3RlcmtlbiBlbiBoZXQgV0xELWFhbmJvZCBtZXQgMTklIHRlIHZlcmhvZ2Vu

2024-04-24, 03:43

<p><img src="https://gimg2.gateimg.com/image/article/171393015624.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Het20HK20Ethereum20ETF20opent20op203020april20voor20de20handel20de20oprichter20van20Worldcoin20ontmoette20Maleisische20leiders20om20de20overheidsrelaties20te20versterken20en20de20WLDvoorraad20in20de20komende20zes20maanden20met201920te20verhogen787300"><a name="Crypto Daily Digest: Het HK Ethereum ETF opent op 30 april voor de handel; de oprichter van Worldcoin ontmoette Maleisische leiders om de overheidsrelaties te versterken en de WLD-voorraad in de komende zes maanden met 19% te verhogen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Het HK <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF opent op 30 april voor de handel; de oprichter van Worldcoin ontmoette Maleisische leiders om de overheidsrelaties te versterken en de WLD-voorraad in de komende zes maanden met 19% te verhogen.</h2><p>Allereerst bekijken we de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens hadden de Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 23 april nog steeds uitstroom van $66,9 miljoen aan fondsen. Ondertussen bedroeg de instroom van Fidelity Bitcoin spot ETF (FBTC) $4,4 miljoen, Bitwise Bitcoin spot ETF (BITB) $23,2 miljoen, ARK 21Shares Bitcoin spot ETF (ARKB) $33,3 miljoen en WisdomTree Bitcoin spot ETF (BTCW) had een nettostroom van $6,6 miljoen.</p>
<p>De spot Bitcoin en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF, gezamenlijk uitgegeven door HashKey Capital en Bosch International, zal op 30 april worden verhandeld op de Hong Kong Stock Exchange. Deze twee ETF’s worden verwacht de prijzen van Bitcoin en Ethereum te volgen en hanteren een fysiek inschrijvingsmechanisme, waardoor investeerders zich rechtstreeks kunnen abonneren op ETF-aandelen met behulp van Bitcoin en Ethereum.</p>
<p>Eerder had Bosch International goedkeuring gekregen van de Hong Kong Securities and Futures Commission om haar zakelijke activiteiten uit te breiden met het aanbieden van vermogensbeheerdiensten met betrekking tot virtuele activa. Tegelijkertijd heeft HashKey Capital, een institutionele virtuele activabeheerinstelling, ook goedkeuring gekregen van de Hong Kong Securities and Futures Commission om virtuele activafondsproductdiensten aan particuliere beleggers te verstrekken.</p>
<p>Aan de SEC-kant zijn we na het eerdere besluit om de Ethereum spot ETF uit te stellen, nu op zoek naar meningen over het herziene voorstel van BlackRock. Beroemde bedrijven, waaronder Fidelity en BlackRock, hebben de afgelopen maanden spot Ethereum ETF’s aangevraagd. Echter, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over de goedkeuring van dergelijke producten door de Amerikaanse Securities and Exchange Commission neemt gestaag af.</p>
<p>Standard Chartered Bank wees er in een onderzoeksrapport op dinsdag op dat digitale activa onlangs te maken hebben gehad met een schadelijke tegenwind storm. De ergste periode is voorbij en de markt bevindt zich in een gunstige positie voor herstel. Analist Jeff Kendrick gelooft dat de instroom van geld in Bitcoin spot ETF’s is gestopt, terwijl Ethereum ETF’s naar verwachting geen goedkeuring zullen krijgen in mei.</p>
<p>Worldcoin heeft onlangs twee tijdelijke verboden gekregen van Spanje en Portugal, waarin wordt geëist dat het verzamelen van persoonlijke gegevens van gebruikers wordt stopgezet. Deze tijdelijke verboden zijn het gevolg van het scannen van de ogen van World Coin-gebruikers om persoonlijke wereld-ID’s te creëren en het verstrekken van WLD-tokens, wat zorgen baart over persoonlijke privacy en gegevensbeheer.</p>
<p>Medeoprichters Sam Altman en Alex Blania ontmoetten onlangs Maleisische leiders om de betrekkingen met de regering te verbeteren en hun toewijding aan het beschermen van gebruikersgegevens en privacy te tonen. Volgens een bericht dat door regeringsleiders is vrijgegeven, namen Blania en Altman, medeoprichters van Tools for Humanity, afgelopen vrijdag deel aan een videogesprek met de Maleisische premier Anwar Ibrahim.</p>
<p>Voorafgaand aan de ontmoeting met Maleisische functionarissen heeft Worldcoin maatregelen genomen om aan te tonen dat het project gegevensverzameling en privacygerelateerde kwesties serieus neemt en bereid is nauwer samen te werken met regulerende instanties en overheidsfunctionarissen. Dit geeft aan dat senior overheidsfunctionarissen nog steeds geïnteresseerd zijn in een dialoog met Worldcoin.</p>
<p>Het is bewezen dat door de toenemende nieuwsgierigheid en zorgen van mensen over kunstmatige intelligentie (inclusief bedreigingen zoals diepe fraude), hooggeplaatste overheidsfunctionarissen uit verschillende landen blijven interesse tonen in een dialoog met Worldcoin.</p>
<p>In het laatste nieuws heeft Worldcoin aangekondigd dat World Assets (een dochteronderneming van de Worldcoin Foundation die verantwoordelijk is voor de uitgifte van tokens) wekelijks tot 1,5 miljoen WLD’s ter waarde van ongeveer $8,2 miljoen zal verkopen via private plaatsingen bij geselecteerde instellingen. Op dit moment bedraagt de omloop van WLD-tokens 193 miljoen, en de verkoop via private plaatsingen betekent een toename van 18,6% in het totale beschikbare aanbod gedurende dezelfde periode.</p>
<h2 id="h2-Markttrends20De20markt20is20volatiel20Meme20coins20blijven20goed20presteren892928"><a name="Markttrends: De markt is volatiel, Meme coins blijven goed presteren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt is volatiel, Meme coins blijven goed presteren</h2><p>De algehele cryptomarkt vertoont een volatiele trend, waarbij de Meme-sector de leiding neemt. Wat betreft de macro-economie is de Amerikaanse aandelenmarkt hersteld, waarbij de productiegegevens lager zijn dan de marktverwachtingen, wat in zekere mate de marktverwachtingen heeft verhoogd voor mogelijke toekomstige renteverlagingen.</p>
<h3 id="h3-Markt20Hotspots538467"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>De Meme sector blijft sterk presteren: verschillende belangrijke tokens in de Meme sector, zoals BONK, PEPE en FLOKI, zagen een dagelijkse stijging van meer dan 20%. Door het gebrek aan druk van het vrijgeven van veel tokens heeft dit type token een relatief eenvoudige chipstructuur en minder weerstand tegen marktmanipulatie, waardoor het opvallend is.</p>
<p>De AI-concepttoken AKT steeg: Akash, een AI-rekenkrachtproject in het Cosmos-ecosysteem, werd gisteren gelanceerd op een Zuid-Koreaanse beurs en het nieuws zorgde voor een aanzienlijke stijging van de prijs. Dit project heeft veel aandacht gekregen van de markt door gedecentraliseerde cloudcomputingbronnen te bieden ter ondersteuning van verschillende AI-rekenbehoeften.</p>
<p>De BIGTIME en BNX van het Gamefi-concept zijn gestegen. Gisteren werden BIGTIME-tokens gelanceerd op een Koreaans handelsplatform, wat algemene marktaandacht en investeringsenthousiasme voor het gameproject heeft veroorzaakt. Tegelijkertijd heeft de BNX-token een aanzienlijke prijsstijging gezien als gevolg van geruchten over een nieuwe gamerelease, wat aangeeft dat investeerders optimistisch blijven over game-innovatie en potentiële bedrijfsmodellen in de Gamefi-sector.</p>
<p>Hoewel de cryptomarkt over het algemeen volatiel is, tonen de sterke prestaties van de Meme-sector en de prominente winsten in AI- en Gamefi-concepten de investeringsactiviteit en marktaandacht van specifieke sectoren aan. Investeerders moeten blijven letten op macro-economische indicatoren en interne ontwikkelingen in de industrie om verstandigere investeringskeuzes te maken. Tegelijkertijd moet aandacht worden besteed aan de risico’s van marktfluctuaties.</p>
<h2 id="h2-Macro20Technologieaandelen20ondersteunen20een20positief20sentiment20op20de20markt20waarbij20beleggers20aandacht20besteden20aan20belangrijke20economische20gegevens20in20de20Verenigde20Staten936153"><a name="Macro: Technologieaandelen ondersteunen een positief sentiment op de markt, waarbij beleggers aandacht besteden aan belangrijke economische gegevens in de Verenigde Staten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Technologieaandelen ondersteunen een positief sentiment op de markt, waarbij beleggers aandacht besteden aan belangrijke economische gegevens in de Verenigde Staten</h2><p>De Amerikaanse aandelenmarkt sloot dinsdag hoger, voornamelijk ondersteund door de goede prestaties van topbedrijven, waarbij beleggers letten op de kwartaalprestaties van Magnificent Seven en andere grote groeiaandelen. Tesla kondigde de lancering aan van een nieuw elektrisch voertuigmodel na het sluiten van de handel op dinsdag, en hoewel de kwartaalomzet lager was dan de verwachtingen van analisten, steeg de aandelenkoers met 6% tijdens de verlengde handelsuren.</p>
<p>Van de elf sectoren van de S&amp;P 500-index stegen er tien, gedreven door de stijging van aandelen in de communicatiediensten. De S&amp;P-materialensector werd echter naar beneden getrokken door staalproducent NUE. N, waarvan de aandelenkoers met 8,9% daalde nadat de winst van het eerste kwartaal onder de verwachtingen lag.</p>
<p>Uit de gegevens van dinsdag blijkt dat de bedrijvigheid in de Verenigde Staten in april op het laagste niveau in vier maanden is gedaald als gevolg van een zwakke vraag. Ondanks een aanzienlijke stijging van de invoerprijzen is de inflatie nog steeds licht vertraagd, wat erop wijst dat de prijsstijgingen voor consumenten mogelijk zijn afgenomen.</p>
<p>Naast de bedrijfswinsten zullen investeerders nauwlettend toezien op de index van de persoonlijke consumptie-uitgaven (PCE) van maart, die op vrijdag zal worden vrijgegeven als de voorkeursinflatie-indicator van de Federal Reserve. Volgens gegevens van de London Stock Exchange verwacht de geldmarkt slechts een renteverlaging van ongeveer 43 basispunten, wat ongeveer 150 basispunten lager is dan aan het begin van het jaar.</p>
<p>Lerner voegde eraan toe: “Het PMI-rapport en de werkgelegenheid zijn relatief zwak, en de markt ziet dit momenteel als slecht nieuws, maar er is ook goed nieuws, wat betekent dat de verwachtingen van mensen ten aanzien van de Federal Reserve te havikachtig zijn geworden.”</p>
<p>De Aziatische aandelenmarkt heeft ook een optimistische trend laten zien na de stijging van Wall Street, gestimuleerd door optimistische winsten van een aantal Amerikaanse bedrijven, wat heeft geleid tot een toename van het marktrisicosentiment.</p>
<p>De MSCI, de meest gebruikte Aziatisch-Pacifische aandelenindex buiten Japan, steeg op dinsdag met 1% en 1,55% na te herstellen van de scherpe verkoopdruk vorige week op de aandelenmarkt. De Nikkei-index in Japan steeg met 2%. De Chinese aandelenmarkt vertoont een gemengde trend van ups en downs, waarbij de blue-chip index onveranderd blijft, terwijl de Hang Seng Index in Hongkong met 1,6% is gestegen.</p>
<p>Wat betreft grondstoffen daalde de Amerikaanse ruwe olie met 0,1% tot $83,28 per vat, terwijl de Brent ruwe olie met 0,12% daalde tot $88,31 per vat. Op dinsdag, toen investeerders hun aandacht verlegden van de gespannen situatie in het Midden-Oosten, stegen de olieprijzen.</p>
<p>Spot goud daalde met 0,2% tot $2.317,39 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 visie van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen in verband met auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>