RGFnZWxpamtzIG5pZXV3cyB8ICJBSSBTdXBlciBBbGxpYW5jZSIgaGVlZnQgZGUgQVNJLWZ1c2llZGF0dW0gYmVwYWFsZDsgTGF5ZXJaZXJvIHZlcmJvbmRlbiBtZXQgU29sYW5hIEJsb2NrY2hhaW47IEJsYWNrUm9jayBoZWVmdCBlZW4gaGVyemllbmUgUy0xLXJlZ2lzdHJhdGlldmVya2xhcmluZyBpbmdlZGllbmQgdm9vciBFVEggRVR

2024-05-30, 03:50

<p><img src="https://gimg2.gateimg.com/image/article/17170409121_20.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Artificial20Intelligence20Super20Alliance20bepaalt20de20fusiedatum20van20ASItokens20LayerZero20bevestigt20verbinding20met20Solana20blockchain20BlackRock20heeft20een20herziene20S120registratieverklaring20ingediend20voor20Ethereum20ETFs326876"><a name="Crypto Daily Digest: “Artificial Intelligence Super Alliance” bepaalt de fusiedatum van ASI-tokens; LayerZero bevestigt verbinding met Solana blockchain; BlackRock heeft een herziene S-1 registratieverklaring ingediend voor Ethereum ETF’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: “Artificial Intelligence Super Alliance” bepaalt de fusiedatum van ASI-tokens; LayerZero bevestigt verbinding met <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> blockchain; BlackRock heeft een herziene S-1 registratieverklaring ingediend voor <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF’s</h2><p>Allereerst, laten we kijken naar <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s handelsactiviteiten. Volgens Farside Investor-data kenden de Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 29 mei voortdurende uitstroom van 31,1 miljoen dollar aan fondsen. Ondertussen was er een instroom van 17,7 miljoen dollar voor Fidelity Bitcoin spot ETF (FBTC), 11 miljoen dollar voor Bitwise Bitcoin spot ETF (BITB), 4 miljoen dollar voor ARK 21Shares Bitcoin spot ETF (ARKB) en 1,1 miljoen dollar netto instroom van fondsen voor The WisdomTree Bitcoin spot ETF (BTCW).</p>
<p><strong><a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a>, SingularityNET en Ocean Protocol bepalen de fusiedatum voor AI Super Alliance-tokens</strong><br>Drie platforms voor kunstmatige intelligentie - Fetch.ai, SingularityNET en Ocean Protocol - zullen de tokenfusie op 13 juni voltooien, en FET zal in de eerste twee dagen worden hernoemd tot ASI.</p>
<p>Deze protocollen die zijn gewijd aan kunstmatige intelligentie zullen op 13 juni een drievoudige fusie van cryptotokens voltooien, geleid door <a href="/price/fetch-ai-fet" target="_blank" class="blog_inner_link">Fetch.ai</a> (FET). Na de fusie zal Fetch.ai worden hernoemd tot ASI, wat staat voor de Artificial Intelligence Super Intelligence Alliance. De twee bedrijven hebben woensdag aangekondigd dat gebruikers vanaf 11 juni FET kunnen omwisselen voor ASI, en de inheemse tokens van SingularityNET (AGIX) en Ocean Protocol (OCEAN) zullen twee dagen na de fusie worden omgewisseld.</p>
<p>Kunstmatige intelligentie is het middelpunt geweest van de technologiegemeenschap gedurende het afgelopen jaar en een half. Mensen maken zich zorgen dat technologiegiganten zoals Microsoft (MSFT), Alphabet (GOOG) en Meta (META) een dominante positie zullen innemen in dit veld. Deze zorg heeft Web3-bedrijven aangespoord om te proberen een gedecentraliseerde kunstmatige intelligentie-infrastructuur op te bouwen die gegevens transparant maakt en openbaar deelt onder bijdragers.</p>
<p><strong>LayerZero verbonden met <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> blockchain</strong><br>Het crypto bridging-protocol LayerZero zal worden uitgebreid naar het Solana-blockchain, waardoor Solana-houders activa kunnen overdragen tussen 70 ketens zoals Arbitrum, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>.</p>
<p>LayerZero zal woensdag uitbreiden naar het Solana blockchain-netwerk, waardoor er een nieuwe manier ontstaat om crypto-activa over te dragen tussen Ethereum en zijn grootste concurrent. Layer Zero Labs, dat het brugprotocol heeft ontwikkeld, verklaarde dat crypto-houders op Solana hun activa kunnen overzetten naar Arbitrum, Ethereum, <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> en 70 andere netwerken, en vice versa.</p>
<p>LayerZero is een brugplatform dat informatie kan overdragen tussen losgekoppelde blockchains. Onderzoeksbureau Messari zei dat gebruikers in het eerste kwartaal van 2024 $6,7 miljard aan cryptocurrency hebben overgedragen, wat $11,5 miljoen aan inkomsten heeft gegenereerd.</p>
<p>In een grote financieringsronde die in april werd aangekondigd, waardeerden private durfkapitalisten LayerZero Labs op $3 miljard. Het protocol zal naar verwachting binnenkort zijn eigen token uitgeven. Solana’s eigen token $SOL is de op vier na grootste cryptocurrency van CoinGecko op basis van marktkapitalisatie, en het heeft ook drie andere grote brugprotocollen verbonden met het Ethereum-ecosysteem, waarvan de bekendste Wormhole is.</p>
<p><strong>BlackRock heeft een herziene S-1 registratieverklaring ingediend voor de aankomende Ethereum ETF</strong><br>BlackRock heeft een herziene registratieverklaring ingediend, waarin meer openbaarmakingsinhoud is toegevoegd aan zijn voorgestelde Ethereum-fonds, wat het nieuwste initiatief van het bedrijf is om zijn producten te laten noteren en verhandelen.</p>
<p>Bijna een week nadat de Securities and Exchange Commission de 19b-4 formulieren voor acht Ethereum ETF’s (inclusief BlackRock’s voorgestelde iShares Ethereum Trust) heeft goedgekeurd, heeft BlackRock een herziene S-1 registratieverklaring ingediend. De uitgever kan pas beginnen met handelen nadat de S-1-verklaring van kracht is geworden.</p>
<p>In het herziene document heeft BlackRock informatie bekendgemaakt over zijn initiële investeerders. BlackRock verklaarde: “Op 21 mei 2024 hebben initiële investeerders (gelieerde ondernemingen van de initiatiefnemers) onder voorwaarden een initiële creatie mandje gekocht, bestaande uit 400.000 aandelen voor $25,00 per aandeel.” Het bedrijf verklaarde ook dat deze aandelen genoteerd en verhandeld zouden worden onder de aandelencode “ETHA”.</p>
<p>De SEC is onlangs begonnen met besprekingen met emittenten over het S-1 formulier. Het is momenteel onduidelijk hoelang dit proces zal duren en sommige analisten speculeren dat het mogelijk enkele weken kan duren.</p>
<h2 id="h2-Markttrends20De20markt20maakt20over20het20algemeen20een20terugtrekking20mee20waarbij20volledig20circulerende20Mememunten20het20goed20doen161205"><a name="Markttrends: De markt maakt over het algemeen een terugtrekking mee, waarbij volledig circulerende Meme-munten het goed doen." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt maakt over het algemeen een terugtrekking mee, waarbij volledig circulerende Meme-munten het goed doen.</h2><p>Bitcoin bevindt zich momenteel in een volatiele neerwaartse trend, die mogelijk te wijten is aan instabiele marktsentimenten of macro-economische factoren.</p>
<p>Ethereum consolideert onder de $3.800, wat aangeeft dat er momenteel geen duidelijke richting is voor de markt.</p>
<p>De meeste Altcoins hebben een daling doorgemaakt, wat kan wijzen op een verhoogde risicoaversie op de markt.</p>
<p>Ondanks de algehele marktdaling presteerden volledig circulerende Meme-concepttokens relatief goed.</p>
<h3 id="h3-Macroeconomie910902"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>Amerikaanse aandelen consolideren zich in de buurt van historische hoogtepunten: De Amerikaanse aandelenmarkt kan op korte termijn het risico lopen op een terugval.</p>
<p>Verhoogde Amerikaanse obligatierendementen: De stijging van de Amerikaanse obligatierendementen kan risicovolle activa, waaronder de cryptomarkt, onder druk zetten.</p>
<h3 id="h3-Markt20Hotspots113696"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>AUDION, CTK en andere tokens met intraday schommelingen van meer dan 100%: Deze relatief kleine tokens hebben aanzienlijke schommelingen doorgemaakt vanwege hun goede chipstructuur en het nieuws van hun lancering op de Koreaanse beurs.</p>
<p>AI-concepttokens zijn in opkomst (ARKM WLD, PHB: beïnvloed door de opeenvolgende historische hoogtepunten die zijn gezet door de Amerikaanse techleider Nvidia, zagen de AI-concepttokens aanzienlijke stijgingen.</p>
<p>Ton ecosysteem meme-token is NIET gestegen: NIET doorbrak vroeg vandaag $0,01, met een wekelijkse stijging van meer dan 100%, DWF-laboratoria hebben een belangrijke rol gespeeld als marktmakers.</p>
<p>De op Ethereum gebaseerde Meme-munt PEPE TURBO en andere munten hebben terugroepacties ervaren: deze trending Meme-tokens, die eerder opeenvolgende nieuwe hoogtepunten hadden bereikt, maken momenteel enkele terugtrekkingen door.</p>
<p>BTC-ecosysteem-inie en runetokens zijn gestegen: DOGs RUNCOIN, PUPS, WZRD en andere relevante tokens hebben allemaal aanzienlijke stijgingen gezien, vooral met de marktkapitalisatie van DOG die de inieleider ORDI bijna gaat overtreffen.</p>
<p>De huidige markt presenteert een relatief complexe situatie. Mainstream munten zoals BTC en ETH bevinden zich in een staat van volatiliteit of consolidatie, terwijl sommige tokens met een kleine marktkapitalisatie en specifieke concepttokens (zoals Meme en AI-concepten) het goed doen. Investeerders moeten letten op risicobeheer in de huidige omgeving, vooral in situaties met een hoge marktvolatiliteit. Met name de mogelijkheid van volledig circulerende Meme- en AI-concepttokens verdient aandacht, terwijl ook de mogelijke impact van macro-economische factoren op de markt in de gaten moet worden gehouden.</p>
<h2 id="h2-Macro20De20rente20veroorzaakte20bezorgdheid20en20obligatierendementen20stegen20Wall20Street20sloot20lager20Aziatische20aandelen20en20obligatiemarkten20daalden448141"><a name="Macro: De rente veroorzaakte bezorgdheid en obligatierendementen stegen, Wall Street sloot lager; Aziatische aandelen- en obligatiemarkten daalden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De rente veroorzaakte bezorgdheid en obligatierendementen stegen, Wall Street sloot lager; Aziatische aandelen- en obligatiemarkten daalden</h2><p>Op woensdag 29 mei sloot de Amerikaanse aandelenmarkt lager, doordat het rendement van Amerikaanse staatsobligaties bleef stijgen en de markt zich meer zorgen maakte over het tijdstip en de omvang van de renteverlaging van de Fed. De Dow Jones-index daalde met meer dan 1% naar het laagste niveau in bijna een maand, waarbij alle sectoren van de S&amp;P 500-index daalden, waarbij rentegevoelige nutsbedrijven de grootste daling doormaakten.</p>
<p>Specifiek daalden de drie belangrijkste indices: de Dow Jones-index daalde met 1,06%, de S&amp;P 500-index daalde met 0,74% en de Nasdaq-index daalde met 0,58%.</p>
<p>De belangrijkste focus van de markt ligt op de aankomende publicatie van het US Core Personal Consumption Expenditure (PCE) Price Index-rapport op vrijdag, dat de voorkeursinflatie-indicator is van de Federal Reserve. De markt verwacht dat de maandelijkse gegevens van de index stabiel zullen blijven.</p>
<p>Ondertussen bleven de rendementen van Amerikaanse schatkistobligaties op donderdag hoog als gevolg van de slechte prestaties van de obligatieveiling de vorige dag. Het rendement op benchmark 10-jarige schatkistobligaties bedroeg onlangs 4,6197% en het rendement op tweejarige schatkistobligaties stabiliseerde op 4,9830%.</p>
<p>Op donderdag 30 mei daalden Aziatische aandelenmarkten over de hele linie vanwege weddenschappen dat de wereldwijde rentetarieven langdurig hoog zouden blijven. Ook de obligatiemarkt kende een daling. Beleggers kunnen dit weekend een oogje houden op belangrijke inflatiedata om verdere aanwijzingen te vinden over de toekomstige koers van het monetaire beleid.</p>
<p>De Amerikaanse dollar steeg als gevolg van het hogere rendement van Amerikaanse schatkistobligaties, terwijl goud onder druk stond vanwege de verwachting van de markt dat de Federal Reserve op korte termijn waarschijnlijk de rente niet zal verlagen.</p>
<p>De gegevens tonen aan dat er nog steeds inflatoire druk is in grote economieën, en de wereldwijde opleving in durfkapitaal is opnieuw tot stilstand gekomen. De MSCI Asia Pacific aandelenindex zette zijn daling van 1,6% voort ten opzichte van de vorige handelsdag, in navolging van de neerwaartse trend op Wall Street. De Nikkei-index in Japan daalde met 1,5%, terwijl ook de Amerikaanse en Europese futures daalden.</p>
<p>In andere regio’s van Azië daalden de blue chip-aandelen op het vasteland van China nog steeds met 0,25%, ondanks de verhoging van de IMF-prognose voor de groei van het BBP van China in 2024 en 2025; De Hang Seng Index in Hong Kong steeg met 0,17%.</p>
<p>In de valutamarkt heeft de Amerikaanse dollar de overhand en is de euro onderdrukt tot het laagste punt in meer dan twee weken, $1.07955. De laatste prijs van de Japanse yen ten opzichte van de Amerikaanse dollar was 157,43, nadat deze op de vorige handelsdag was gedaald tot een dieptepunt van vier weken van 157,715.</p>
<p>De Indiase roepie wordt verwacht te dalen op donderdag, omdat de zorgen over het aanbod hebben geleid tot een verdere stijging van de opbrengsten van Amerikaanse staatsobligaties en de Amerikaanse dollarkoers steeg naar het hoogste niveau in twee weken. Na een piek van 83,0250 op vrijdag, daalde de roepie drie opeenvolgende dagen en bereikte woensdag de grootste dagelijkse daling in zeven weken.</p>
<p>Op de grondstoffenmarkt stegen de olieprijzen lichtjes en herwonnen ze een deel van het verloren terrein van woensdag, als gevolg van zorgen over zwakke vraag naar benzine in de Verenigde Staten en hoge rentetarieven op lange termijn. Brent ruwe olieprijzen bleven stabiel op $83.60 per vat, terwijl de prijzen van Amerikaanse ruwe olie met 0.03% stegen naar $79.25 per vat.</p>
<p>De prijs van spotgoud daalde met 0,2% tot $2.334,15 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 mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten van dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>