RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBzdGlqZ3Q7IE1pY3JvU3RyYXRlZ3kgd2VyZCBvcGdlbm9tZW4gaW4gYmVsYW5ncmlqa2Ugd2VyZWxkd2lqZGUgYWFuZGVsZW5pbmRpY2VzOyBXTEQgaGVlZnQgZWVuIGdldm9lbGlnIGluZm9ybWF0aWViZXZlaWxpZ2luZ3NzeXN0ZWVtIHVpdGdlYnJhY2h0LCB3YWFyaW4gc3RhYXQgZGF0IGRlIGl

2024-05-16, 03:08

<p><img src="https://gimg2.gateimg.com/image/article/17158288711_9.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20MicroStrategy20is20opgenomen20in20belangrijke20wereldwijde20aandelenindexen20Worldcoin20heeft20een20gevoelig20informatiebeveiligingssysteem20uitgebracht20en20verklaarde20dat20de20iriscode20van20de20gebruiker20is20verwijderd20Yonsei20University20heeft20een20metaverse20gelanceerd20dat20studenten20in20staat20stelt20toegang20te20krijgen510562"><a name="Crypto Dagelijkse Samenvatting: MicroStrategy is opgenomen in belangrijke wereldwijde aandelenindexen; Worldcoin heeft een ‘gevoelig informatiebeveiligingssysteem’ uitgebracht en verklaarde dat de iriscode van de gebruiker is verwijderd; Yonsei University heeft een metaverse gelanceerd dat studenten in staat stelt toegang te krijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: MicroStrategy is opgenomen in belangrijke wereldwijde aandelenindexen; Worldcoin heeft een ‘gevoelig informatiebeveiligingssysteem’ uitgebracht en verklaarde dat de iriscode van de gebruiker is verwijderd; Yonsei University heeft een metaverse gelanceerd dat studenten in staat stelt toegang te krijgen</h2><p>Laten we eerst de handelsactiviteiten van onderzoeken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor ontvingen Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 15 mei nog steeds instromen van $2.700 aan fondsen; Tegelijkertijd ontving Fidelity Bitcoin spot ETF (FBTC) een instroom van $131,3 miljoen, Bitwise Bitcoin spot ETF (BITB) een instroom van $86,3 miljoen, ARK 21Shares Bitcoin spot ETF (ARKB) een instroom van $38,6 miljoen, en WisdomTree Bitcoin spot ETF (BTCW) een nettostroom van $2,1 miljoen.</p>
<p>Na de opening van Wall Street bereikte BTC een lokaal hoogtepunt van $64.700. Door de laatste gegevens van de Amerikaanse Consumentenprijsindex (CPI) die de verwachtingen van risicovolle activa overtroffen, zijn de Bitcoin-bulls gestegen.</p>
<p>De grootste Bitcoin-ondernemingshouder, het business intelligence bedrijf MicroStrategy, is opgenomen in belangrijke wereldwijde aandelenindices nadat de aandelenkoers sterk steeg.</p>
<p>Op dinsdag maakte de wereldwijde aanbieder van investeringsbeslissingsondersteuningstools MSCI (voorheen Morgan Stanley Capital International) bekend dat MicroStrategy een van de drie grootste nieuwe producten qua marktwaarde is geworden in zijn MSCI World Index, die op 31 mei van kracht wordt.</p>
<p>Sinds de bodem van de cryptomarkt in december 2022 is de aandelenkoers van MicroStrategy omhooggeschoten. Volgens de gegevens van TradeView is de aandelenkoers sindsdien meer dan acht keer gestegen, met een stijging van meer dan 87% tot nu toe dit jaar, wat de stijging van Bitcoin van 45% in 2024 overtreft.</p>
<p>Sinds de laatste aankoop van Bitcoin op 29 april houdt MicroStrategy 214.400 Bitcoins vast, ter waarde van ongeveer $13,5 miljard. De totale aanschafkosten van MicroStrategy bedragen $7,5 miljard, met een gemiddelde prijs van $35.180 per Bitcoin, wat betekent dat het bedrijf ongeveer $6 miljard aan boekwinst heeft verdiend uit Bitcoin-aankopen.</p>
<p>Gezien zijn grote Bitcoin-posities (gelijk aan meer dan 1% van de totale voorraad van 21 miljoen Bitcoins) wordt MicroStrategy steeds vaker gebruikt als een proxy voor Bitcoin-belangen in traditionele markten, vooral voor de lancering van Bitcoin-beursgenoteerde fondsen in de Verenigde Staten in januari.</p>
<p>Eerder deze maand kondigde MicroStrategy plannen aan om een gedecentraliseerde identiteitsoplossing te lanceren op basis van Bitcoin.</p>
<p>Worldcoin streeft naar het vestigen van ‘nieuwe normen’ op het gebied van gegevensbescherming en verklaart dat het gebruikers iris-codes heeft verwijderd. De Worldcoin Foundation heeft een open-source systeem uitgebracht dat beweert de bescherming van gevoelige informatie te verbeteren, inclusief gegevens die worden gegenereerd wanneer mensen zich registreren voor Worldcoin-projecten.</p>
<p>Een verklaring merkte op: ‘Het systeem is beschikbaar gesteld aan alle organisaties in het Github-opslagplaats met als doel nieuwe normen te stellen voor gegevensbescherming, inclusief biometrische gegevens.’ Worldcoin verklaarde dat dit nieuwe open source systeem is gebaseerd op veilig multi-party computing.</p>
<p>De World Coin Foundation heeft aangekondigd dat ze zijn overgestapt naar dit nieuwe systeem en de oude iris-codes hebben verwijderd die eerder waren verzameld door de ogen van gebruikers te scannen die zich hadden geregistreerd voor het World Coin-project via Orb-apparaten. Tijdens dit proces zal het World Coin-project mensen cryptocurrency of WLD-tokens verstrekken wanneer ze zich registreren en hun ogen scannen om hun identiteit te bewijzen en digitale identiteiten te creëren.</p>
<p>Via veilige multi-party computation (SMPC) kan data veilig worden gedistribueerd over verschillende locaties. Het Internationaal Monetair Fonds verklaarde in een verklaring: “Dit kan worden gezien als het verkrijgen van een <a href="/price/secret-scrt" rel="nofollow noopener noreferrer" target="_blank">Geheim</a> en het delen van meerdere onderdelen onder verschillende partijen om de bescherming te verbeteren. Het Internationaal Monetair Fonds heeft in samenwerking met de TACO en technische experts van Tools for Humanity met succes een nieuw uitvoeringsplan voor SMPC opgesteld om eerdere problemen aan te pakken die anderen hebben belemmerd vanwege omvang en kostenbeperkingen.</p>
<p>LG Uplus, een dochteronderneming van LG, heeft onlangs de Metaverse Experience gelanceerd op de Yonsei Universiteit in Seoul. Deze metaverse-ervaring staat bekend als de “Meta Yonsei”, gekenmerkt door de reconstructie van de nieuwe dorpscampus van de universiteit, inclusief bezienswaardigheden zoals het schoolauditorium en de bibliotheek, en het bieden van gelaagde toegang tot digitale bronnen en privévergaderruimtes voor docenten en studenten.</p>
<p>In tegenstelling tot veel andere metaverse-ervaringen beperkt Yuan Yanshi veel functies tot gideerde studenten. Hoewel toekomstige studenten en andere bezoekers lijken te kunnen rondwandelen op de virtuele campus, de functies en bezienswaardigheden kunnen bekijken, gebruikmaken van de bijbehorende vergadertools en toegang krijgen tot bepaalde gebieden van het virtuele universum zijn beperkt tot geregistreerde studenten. De ervaring van Metaverse Yonsei University is goed ontvangen door studenten op de campus.</p>
<p>Studenten en docenten kunnen ook met elkaar communiceren via gestructureerde incheck- en toezichtactiviteiten. Volgens een rapport dat is uitgebracht door het project in 2023, kunnen er tot 1000 gebruikers deelnemen aan virtuele evenementen in de Metaverse Auditorium (een digitale versie van de echte faciliteiten van de universiteit), inclusief de mogelijkheid om gast sprekers en experts op een virtueel podium te bekijken.</p>
<h2 id="h2-Markttrends20BTC20steeg20US20CPIgegevens20beter20dan20verwacht673860"><a name="Markttrends: BTC steeg, US CPI-gegevens beter dan verwacht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC steeg, US CPI-gegevens beter dan verwacht</h2><p>De prijs van BTC heeft $66.000 doorbroken en heeft een nieuw hoogtepunt bereikt, wat ook heeft geleid tot de algehele stijging van Altcoins. Echter, de wisselkoers ETH/BTC heeft een nieuw dieptepunt bereikt in bijna drie jaar, wat aangeeft <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> zwakte ten opzichte van Bitcoin.</p>
<p>Op macro-economisch gebied is de Amerikaanse aandelenmarkt blijven stijgen en heeft een historisch hoogtepunt bereikt, terwijl de Amerikaanse dollarkoers scherp is gedaald. De gisteren gepubliceerde CPI-gegevens van april in de Verenigde Staten lieten een maand-op-maand daling zien, wat de markt in het algemeen deed verwachten dat de Federal Reserve de rente in september zal verlagen, waarbij de verwachting van de markt dit met meer dan 80% heeft overtroffen.</p>
<h3 id="h3-Markt20Hotspots832369"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>De meme munten van het Amerikaanse verkiezingsconcept, inclusief tokens zoals PEOPLE, MAGA, BODEN, TREMP, enz., hebben een significante prijsstijging gezien. Het wordt verwacht dat deze concept tokens markthype zullen blijven ontvangen voor de Amerikaanse verkiezingen in november.</p>
<p>AI-concepttokens, waaronder AR, PHB, LPT, OCTA, etc., hebben aanzienlijke stijgingen gezien in de huidige markttrend. De concepten van AI en Meme zijn altijd de belangrijkste drijvende krachten van de markt geweest, en deze gerelateerde tokens hebben algemene kracht getoond in de stijgende markt.</p>
<p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ecosysteem: Tokens zoals JTO, <a href="/price/gmx-gmx" rel="nofollow noopener noreferrer" target="_blank">GMX</a>, en BOME hebben aanzienlijke prijsstijgingen gezien, mogelijk profiterend van de SOL-stakingactiviteit van Robinhood. Tokens onder het Solana-ecosysteem hebben een relatief actieve trend laten zien op de markt.</p>
<p>Gate.io lanceerde het Ton Eco Meme-project Notcoin: Het totale aantal NOT-chips is 100 miljard, en de chips circuleren volledig. De markt voorspelt dat de marktwaarde rond de $800 miljoen ligt. Deze stap heeft de aandacht van de markt getrokken naar het project en kan ook een van de toekomstige hotspots worden.</p>
<p>Populaire Layer2-netwerk Blast Airborne Tokens: Blast is de Layer2 van NFT-handelsplatform Blur, dat heeft aangekondigd dat het tokens zal airdroppen op 26 juni. Deze zet is mogelijk gericht op het stimuleren van handelsvolume op het Blur-platform, vooral na te zijn ingehaald door Magic Eden op het Solana-platform, dat zijn handelsactiviteit moet verhogen door meer gebruikers aan te trekken.</p>
<p>In de huidige markt, hoewel BTC een recent hoogtepunt heeft bereikt, is de prestatie van ETH ten opzichte van BTC relatief zwak. Op macro-economisch gebied blijft de Amerikaanse aandelenmarkt stijgen, maar de Amerikaanse dollarindex vertoont een neerwaartse trend. De markthotspots richten zich voornamelijk op het Amerikaanse verkiezingsconcept, het AI-concept en het Solana-ecosysteem. Investeerders moeten deze hotspots nauwlettend volgen en ze analyseren en bedienen in combinatie met hun eigen investeringsstrategieën.</p>
<h2 id="h2-Macro20CPIgegevens20stimuleren20weddenschappen20op20renteverlaging20Wall20Street20sluit20op20een20historisch20hoogtepunt20en20Aziatische20markten20stijgen989857"><a name="Macro: CPI-gegevens stimuleren weddenschappen op renteverlaging, Wall Street sluit op een historisch hoogtepunt en Aziatische markten stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: CPI-gegevens stimuleren weddenschappen op renteverlaging, Wall Street sluit op een historisch hoogtepunt en Aziatische markten stijgen</h2><p>Op woensdag 15 mei sloten alle drie belangrijke Wall Street-beursindexen hoger, waarbij de S&amp;P 500-index en de Nasdaq beide records vestigden en meer dan 1% stegen. De drie belangrijkste aandelenindices bereikten allemaal historische hoogtepunten tijdens de handelssessie, waarbij technologieaandelen voorop liepen. De blue-chip aandelenmarkt is een stap dichter bij de mijlpaal van 40.000 voertuigen.</p>
<p>De gegevens die op woensdag door de Verenigde Staten zijn vrijgegeven, toonden aan dat de consumentenprijsindex (CPI) in april met 0,3% is gestegen, lager dan de verwachte stijging van 0,4%, wat de hoop vergroot dat de Federal Reserve dit jaar tweemaal de rente zou kunnen verlagen.</p>
<p>Specifiek stegen de drie belangrijkste indices: de Dow Jones-index steeg met 0,88%, de Standard &amp; Poor’s-index steeg met 1,17% en de Nasdaq-index steeg met 1,40%.</p>
<p>De lauwe gegevens over de Amerikaanse Consumentenprijsindex (CPI) in april duiden erop dat de inflatie vertraagt na drie opeenvolgende maanden van hoger dan verwachte gegevens, wat <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> Dit heeft ertoe geleid dat handelaren hun weddenschappen hebben verhoogd dat de Federal Reserve het beleidstarief zal verlagen in september en december.</p>
<p>Op 16 mei steeg de Aziatische aandelenmarkt. De MSCI Asia Pacific Stock Index steeg met 1,44%. De Hong Kong Hang Seng Index steeg met 0,9%, terwijl het Australische aandelenbenchmark met 1,5% steeg.</p>
<p>De Nikkei-index in Japan steeg aanvankelijk met 1,3%, maar als gevolg van druk vanwege enkele teleurstellende late prestaties op de laatste dag van het financiële rapportageseizoen van woensdag, evenals zorgen over een aanzienlijke stijging van de yen, verminderde de aandelen hun stijging tot 0,6%.</p>
<p>De Amerikaanse dollar bevindt zich nog steeds in een neerwaartse trend en daalt naar nieuwe dieptepunten van enkele weken ten opzichte van valuta zoals de euro en het pond. Het rendement van Amerikaanse staatsobligaties bleef dalen bij de handel in Tokio en bereikte een nieuw dieptepunt van zes weken. Ondanks gegevens die aantonen dat de Japanse economie in het eerste kwartaal meer kromp dan verwacht, hielp dit toch de zwaar beschadigde yen verder te herstellen.</p>
<p>Federal funds futures hebben dit jaar de rente met 52 basispunten verlaagd, waarbij de renteverlaging in september nu volledig is geprijsd.</p>
<p>Futures van Brent ruwe olie stegen met 42 cent, of 0,5%, naar $83,17 per vat, terwijl ruwe olie van West Texas Intermediate (WTI) in de Verenigde Staten met 43 cent, of 0,6%, steeg naar $79,06 per vat, waardoor de sterke winsten van woensdag verder werden verergerd.</p>
<p>De goudprijs steeg met 0,39% naar $2.395,39 en nadert een historisch hoogtepunt van $2.431,29 sinds 12 april.</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 opvattingen van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan het artikel te delen, 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>