RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0byBWQy1oYW5kZWwgYmVyZWlrdGUgaW4gbWFhcnQgaGV0IGhvb2dzdGUgbml2ZWF1IGluIGVlbiBqYWFyOyBJbW11dGFibGUgbGFuY2VlcmRlIGVlbiBiZWxvbmluZ3Nwcm9ncmFtbWEgdmFuIDUwIG1pbGpvZW4gdm9vciBnYW1lczsgV0xEIHphbCBzYW1lbndlcmtlbiBtZXQgUGF5UGFsIE9wZW5

2024-04-26, 03:42

<p><img src="https://gimg2.gateimg.com/image/article/171410289326.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Het20aantal20crypto20VCtransacties20heeft20een20nieuw20jaarlijks20hoogtepunt20bereikt20Immutable20lanceert20een20beloningsprogramma20van205020miljoen20voor20spelletjes20Worldcoin20zal20samenwerken20met20PayPal20OpenAI983503"><a name="Crypto Dagelijkse Samenvatting: Het aantal crypto VC-transacties heeft een nieuw jaarlijks hoogtepunt bereikt; Immutable lanceert een beloningsprogramma van 50 miljoen voor spelletjes; Worldcoin zal samenwerken met PayPal OpenAI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Het aantal crypto VC-transacties heeft een nieuw jaarlijks hoogtepunt bereikt; Immutable lanceert een beloningsprogramma van 50 miljoen voor spelletjes; Worldcoin zal samenwerken met PayPal OpenAI</h2><p>Laten we eerst de handelsactiviteiten van nader bekijken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens Farside Investor-gegevens had Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 25 april een gelduitstroom van $139,4 miljoen. Ondertussen zijn er uitstromen van $22,6 miljoen voor Fidelity Bitcoin spot ETF (FBTC), $6 miljoen voor Bitwise Bitcoin spot ETF (BITB) en $31,3 miljoen voor ARK 21Shares Bitcoin spot ETF (ARKB). Vandaag is er een aanzienlijke uitstroom van Bitcoin spot ETF-fondsen.</p>
<p>Volgens een onderzoeksrapport van CoinTelegraph ervaren cryptocurrencies zoals Bitcoin, ondanks recente marktschommelingen en neergangen, een afkoelingsperiode. In maart 2024 bleef de durfkapitaalmarkt echter herstellen. In maart werden 161 transacties voltooid, wat een recordhoogte in 12 maanden vestigde. De totale investering overtrof $1 miljard, een stijging van 52% op maandbasis. Hoewel april nog niet is afgelopen, zijn er 90 transacties geregistreerd, met meer dan $820 miljoen aan investeringen. In maart bereikte het aantal transacties het hoogste niveau in 12 maanden.</p>
<p>De instroom van nieuw durfkapitaal heeft ook de activiteiten van ontwikkelaars gestimuleerd, vooral opkomende gebieden zoals kunstmatige intelligentie en L1/L2/L3-infrastructuuroplossingen. De infrastructuursector is het meest aantrekkelijk voor investeerders, met een totale investering van meer dan $1,2 miljard in maart en april.</p>
<p>Verschillende fondsen die in de afgelopen maanden zijn aangekondigd of gelanceerd, hebben de heropleving van de crypto-venturekapitaalmarkt gestimuleerd. Naast de bekende Hack VC en Immune x <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> Naast fondsen zijn er ook verschillende nieuwe fondsen uitgebracht. Een van de meest opvallende daarvan is Paradigm, dat aankondigde $850 miljoen te hebben opgehaald om geld terug te sturen naar het crypto-venturekapitaalveld.</p>
<p>Ook de GameFi-industrie heeft tekenen van herstel getoond en ontvangt steun van a16z. Het bedrijf is van plan $30 miljoen te investeren in op technologie gebaseerde game-startups, met de nadruk op kunstmatige intelligentie, virtual reality/augmented reality en Web3-technologie.</p>
<p>Immutable kondigde de lancering aan van het ‘grootste Web3-game-missie- en beloningsprogramma ooit’, waarbij spelers $50 miljoen aan tokenbeloningen krijgen aangeboden. Het bedrijf verklaarde dat het Immutable-ecosysteem meer dan 270 games in ontwikkeling heeft, waaronder veelbelovende projecten zoals Illuvium en MetalCore.</p>
<p>Volgens de aankondiging van het bedrijf kunnen spelers onmiddellijk beloningen ontvangen door missies te verkennen, games te spelen en favorieten te bezitten op Immutable. Met de voortdurende volwassenheid van web3-games en de release van meer games met grotere budgetten voor het publiek, lijkt Immutable meer spelers te willen aantrekken via beloningsprogramma’s.</p>
<p>Bloomberg meldde dat Tools for Humanity, de ontwikkelaar van Worldcoin, geïnteresseerd is in een partnerschap met betalingsgigant PayPal en kunstmatige intelligentiebedrijf OpenAI. De details van de samenwerking zijn echter nog onduidelijk en er zijn nog geen specifieke plannen naar voren gekomen.</p>
<p>Het concept van Worldcoin is om de identiteit van de gebruiker te verifiëren door hun irisinformatie te scannen, en als tegenprestatie kan de gebruiker de crypto WLD verkrijgen. Sam Altman, voorzitter en medeoprichter van Tools for Humanity, is ook medevoorzitter van OpenAI, een bekende ontwikkelaar van Generative AI ChatGPT.</p>
<h2 id="h2-Markttrends20De20markt20is20zwak20en20volatiel20en20de20Memesector20is20het20belangrijkste20verhaal20van20deze20ronde630667"><a name="Markttrends: De markt is zwak en volatiel, en de Meme-sector is het belangrijkste verhaal van deze ronde" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt is zwak en volatiel, en de Meme-sector is het belangrijkste verhaal van deze ronde</h2><p>Bitcoin (BTC) viel gisteravond onder de $63.000 en de algehele cryptomarkt vertoonde een zwakke en volatiele trend. Ondanks de algehele slechte prestaties van de markt, blijft de Meme sector de belangrijkste focus van deze handelsronde, waarbij relatief sterke veerkracht wordt getoond.</p>
<p>Op macro-economisch vlak daalde de Amerikaanse aandelenmarkt. De economische gegevens van het BBP voor het eerste kwartaal van de Verenigde Staten tonen aan dat de economie in stagflatie is beland, terwijl de inflatie al drie opeenvolgende maanden stijgt. Deze factoren hebben gezamenlijk een zware klap toegebracht aan de marktverwachtingen voor renteverlagingen, waardoor de onzekerheid bij investeerders en de marktvolatiliteit verergeren.</p>
<h3 id="h3-Markt20Hotspots583469"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Memesector: Tokens zoals BONK en PEPE in de Memesector hebben sterke prestaties laten zien tegen de wijdverspreide marktdaling. Meme-tokens zijn in deze marktronde het middelpunt van de aandacht van investeerders geworden vanwege hun eerlijke uitgiftemechanisme, goede chipstructuur en geen eerdere druk van durfkapitaal. De uniciteit en gemeenschapsondersteuning van dit type token hebben gezorgd voor stabiele marktprestaties.</p>
<p>De opkomst van Rune Dogs: Als lid van de Rune-serie hebben Dogs een marktwaarde van $500 miljoen en zijn ze gelanceerd op Gate.io. De opkomst van DOG kan worden gedreven door zijn unieke positionering en functionaliteit op de markt, evenals de toegenomen beschikbaarheid van handelsplatforms.</p>
<p>Hoewel de algehele markt volatiel is, vooral in een ongunstige macro-economische context, toont de Meme-sector nog steeds sterke marktprestaties en investeringspotentieel. Investeerders moeten de Meme-sector blijven volgen en nauwlettend veranderingen in de mondiale economische situatie en monetair beleid volgen om tijdig aanpassingen en beslissingen te nemen. In de huidige marktomgeving is het handhaven van een flexibele en voorzichtige beleggingsstrategie bijzonder belangrijk.</p>
<h2 id="h2-Macro20De20wereldwijde20markt20blijft20voorzichtig20met20gemengde20ups20en20downs20Japanse20yencrisis20zoekt20reactie20van20de20Bank20of20Japan790521"><a name="Macro: De wereldwijde markt blijft voorzichtig, met gemengde ups en downs; Japanse yen-crisis zoekt reactie van de Bank of Japan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De wereldwijde markt blijft voorzichtig, met gemengde ups en downs; Japanse yen-crisis zoekt reactie van de Bank of Japan</h2><p>De Wall Street aandelenmarkt sloot lager op donderdag, omdat de gegevens een langzamere dan verwachte economische groei in de VS en aanhoudende inflatie lieten zien, in combinatie met teleurstellende prestaties die leidden tot een verkoopgolf in aandelen met een grote marktkapitalisatie.</p>
<p>De prestaties van Meta onder techreuzen waren onbevredigend, maar de kwartaalresultaten van Alphabet (GOOGL.O) en Microsoft overtroffen de verwachtingen van Wall Street en dreven de futures van de Amerikaanse aandelenindex omhoog. De futures van de Nasdaq stegen meer dan 1%, terwijl de futures van de S&amp;P 500-index met 0,7% stegen.</p>
<p>Volgens gegevens van de London Stock Exchange verwacht de geldmarkt dat de Federal Reserve de rentetarieven dit jaar met ongeveer 36 basispunten zal verlagen, in plaats van ongeveer 150 basispunten aan het begin van het jaar.</p>
<p>Aziatische aandelenmarkten stegen voorzichtig op vrijdag, waarbij de Nikkei Index van Japan licht steeg met 0,02%. De MSCI Asia Pacific Stock Index steeg met 0,27%, terwijl de Australische S&amp;P/ASX 200 Index meer dan 1% daalde. De Hang Seng Index in Hong Kong steeg met 0,3%.</p>
<p>De focus van Azië ligt op het rentebesluit van de Bank of Japan aan het einde van zijn tweedaagse monetair beleidsvergadering, evenals de daaropvolgende persconferentie van gouverneur Ichio Ueda. Voor de resultaten bekend werden gemaakt, was de wisselkoers van de yen tegenover de dollar nauwelijks veranderd, met een schommeling rond een 34-jarig dieptepunt van 155,62 yen, terwijl het rendement van de 10-jarige Japanse staatsobligatie steeg naar een vijfmaands hoogtepunt van 0,93%.</p>
<p>Vanwege het duidelijke begrip van de markt dat de Verenigde Staten waarschijnlijk voor enige tijd de rentetarieven zullen verlagen, zitten Japanse staatsobligaties in de problemen voordat het beleidsbesluit nauwlettend wordt gevolgd door de centrale bank. Wat de situatie voor de Bank of Japan compliceert, is dat de gegevens van vrijdag aantoonden dat de vertraging in de kerninflatie in Tokio in april de verwachtingen overtrof en lager was dan het streefdoel van de Bank van 2%.</p>
<p>Wat betreft grondstoffen stegen de olieprijzen in de vroege handel op vrijdag omdat beleggers de opmerkingen van de Amerikaanse minister van Financiën beoordeelden waarin werd gesteld dat de economie mogelijk sterker is dan blijkt uit de gegevens van het eerste kwartaal, tezamen met zorgen over de aanvoer als gevolg van voortdurende conflicten in het Midden-Oosten. De prijzen van Brent ruwe olie stegen met 34 cent, of 0,38%, tot $89,35 per vat. De prijzen van West Texas Intermediate ruwe olie stegen met 33 cent, of 0,39%, tot $83,90 per vat in de Verenigde Staten.</p>
<p>Goud daalde met 0,08% tot $2.329,50 per ons. De recente algemene stijging van de goudprijzen heeft Newmont (de grootste goudmijnbouwer ter wereld) geholpen winst te maken, met een winst in het eerste kwartaal die de verwachtingen overtrof en de aandelenkoers met 12% steeg.</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 op dit artikel. Het opnieuw posten van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>