RGFnZWxpamtzIG5pZXV3cyB8IFpSTyB3ZXJkIGdlbGFuY2VlcmQsIGNyeXB0b21hcmt0IGJsaWpmdCB0cmFhZzsgM2lRIGhlZWZ0IGFhbmdldnJhYWdkIG9tIGRlIGVlcnN0ZSBTb2xhbmEgRVRQIGluIE5vb3JkLUFtZXJpa2EgdGUgbGFuY2VyZW47IEZFVCBlbiBBR0lYIGxlaWRkZW4gZGUgQUktdG9rZW5zIG9taG9vZy4=

2024-06-21, 03:37

<p><img src="https://gimg2.gateimg.com/image/article/17189408281_16.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest203iQ20heeft20een20aanvraag20ingediend20om20de20eerste20Solana20ETP20in20NoordAmerika20te20lanceren20NVIDIA20is20het20meest20waardevolle20bedrijf20ter20wereld20geworden20met20FET20en20AGIX20als20leiders20van20de20opkomst20van20AItokens20Midas20lanceert20een20op20inkomsten20gebaseerde20token20mBASIS20tegen20Ethna45176"><a name="Crypto Daily Digest: 3iQ heeft een aanvraag ingediend om de eerste Solana ETP in Noord-Amerika te lanceren; NVIDIA is het meest waardevolle bedrijf ter wereld geworden, met FET en AGIX als leiders van de opkomst van AI-tokens; Midas lanceert een op inkomsten gebaseerde token mBASIS tegen Ethna" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: 3iQ heeft een aanvraag ingediend om de eerste <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> ETP in Noord-Amerika te lanceren; NVIDIA is het meest waardevolle bedrijf ter wereld geworden, met FET en AGIX als leiders van de opkomst van AI-tokens; Midas lanceert een op inkomsten gebaseerde token mBASIS tegen Ethna</h2><p>Allereerst, laten 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 bleven Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s (GBTC) op 18 juni een uitstroom van $ 53,1 miljoen aan fondsen ervaren. Ondertussen bedroeg de uitstroom van Fidelity Bitcoin spot ETF (FBTC) $ 51,1 miljoen.</p>
<p><strong>NVIDIA leidt technologieaandelen, terwijl FET en AGIX de stijging in kunstmatige intelligentie tokens leiden</strong><br>De aandelenprijs van chipfabrikant Nvidia is sinds maandag met 5% gestegen, waardoor het Microsoft heeft overtroffen in marktwaarde en ‘s werelds meest waardevolle bedrijf is geworden. Hoewel Nvidia geen directe relatie heeft met een crypto-bedrijf, zorgt de stijging van de aandelenprijs vaak voor een stijging van tokens die verband houden met kunstmatige intelligentie.</p>
<p>In de afgelopen 24 uur zijn de crypto-tokens in de AI-sector met 35% gestegen, veel meer dan de algehele veranderingen in de cryptomarkt. “Het gebied van kunstmatige intelligentie is erg populair in zowel traditionele als cryptomarkten”, zegt Edward Wilson, een analist bij Nansen.ai. De prestaties van Nvidia zijn indrukwekkend en de opkomst van AI-concepttokens wordt verwacht. Tokens zoals NEAR en RNDR zijn het afgelopen jaar met ongeveer 300% gestegen, terwijl ETH in dezelfde periode slechts iets boven de 100% is gestegen, wat wijst op een hoge mate van marktinteresse in het AI-veld.</p>
<p>Volgens de gegevens van CoinGecko, <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a> FET van ’s, AGIX van SingularityNET en OCEAN van Ocean Protocol hebben de groei van kunstmatige intelligentie tokens geleid, met een gemiddelde groeisnelheid van 15% in dit veld. Tokens met een marktwaarde van meer dan $100 miljoen zijn met minstens 4% gestegen, wat aanzienlijk hoger is dan de stijging van 0,22% in de CoinDesk 20 (CD20) index.</p>
<p>Bovendien zullen SingularityNET, <a href="/price/fetch-ai-fet" target="_blank" class="blog_inner_link">Fetch.ai</a> en Ocean Protocol op 15 juli 2024 de ‘Artificial Intelligence Super Alliance’ vormen en de drie tokens samenvoegen tot de ASI-token.</p>
<p><strong>3iQ heeft een aanvraag ingediend om de eerste <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ETP in Noord-Amerika</strong><br>Beleggingsmaatschappij 3iQ heeft een aanvraag ingediend om het eerste Solana Exchange Traded Product (ETP) van Canada te lanceren. Het bedrijf verklaarde donderdag dat de ETP genaamd Solana Fund Canadese beleggers de mogelijkheid zal bieden om te investeren in SOL zonder de noodzaak van hot wallets of andere op blockchain gerelateerde technologieën. Het fonds wordt genoteerd aan de Toronto Stock Exchange onder de beurssymbool QSOL indien goedgekeurd.</p>
<p>Greg Benhaim, utive Vice President en Hoofd Trading bij 3iQ, zei: ‘Als pionier op het gebied van digitaal vermogensbeheer kijken we ernaar uit om onze missie voort te zetten om gereguleerde investeringstools te bieden die voldoen aan de hoogste normen en samen te werken met eersteklas partners om individuen en institutionele beleggers in staat te stellen efficiënt toegang te krijgen tot crypto asset classes.’</p>
<p>Het is momenteel onduidelijk wanneer het Solana Fonds open zal gaan voor investeerders.</p>
<p><strong>Midas lanceerde een nieuwe op inkomsten gerichte token, mBASIS, met als doel Ethena te overtreffen</strong><br>Het tokenisatieplatform Midas heeft een nieuwe inkomsten-token gelanceerd genaamd mBASIS, die tot doel heeft om Ethena te overtreffen. mBASIS is een ERC-20-token dat is genoteerd in Amerikaanse dollars en rendementen behaalt via een ‘delta neutraal basis’-handelsstrategie. Deze handelsstrategie houdt in dat winst wordt gemaakt uit het prijsverschil tussen spot- en eeuwigdurende futures-markten.</p>
<p>Dennis Dinkelmeyer, oprichter van Midas en voormalig beleggingsonderzoeksanalist bij Goldman Sachs, verklaarde dat mBASIS meerdere verschillen heeft ten opzichte van Ethena’s sUSDe. mBASIS wordt beheerd door een toonaangevend vergund vermogensbeheerbedrijf dat onder toevertrouwde verantwoordelijkheid opereert om ervoor te zorgen dat het investeringsproces in het beste belang van beleggers is. De activa van mBASIS worden beheerd door een onafhankelijke gereguleerde fondsbeheerder, NAV Consulting.</p>
<p>Daarnaast biedt mBASIS faillissementsbescherming, waar klantactiva worden opgeslagen in bijzondere doelentiteiten onder faillissementsbescherming. De veiligheidsagent zal de activa onder de schuldeisers verdelen als er een wanbetaling optreedt.</p>
<p>Dinkelmeyer voegde eraan toe dat mBASIS streeft naar hogere rendementen dan de markt door actief de basisposities van de top 20 Altcoins toe te wijzen, die doorgaans hogere rendementen opleveren dan Bitcoin en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<h2 id="h2-Markttrends20Het20ZROproject20is20eindelijk20gelanceerd20maar20de20reactie20van20de20gemeenschap20is20zeer20heftig20geweest573115"><a name="Markttrends: Het ZRO-project is eindelijk gelanceerd, maar de reactie van de gemeenschap is zeer heftig geweest" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: Het ZRO-project is eindelijk gelanceerd, maar de reactie van de gemeenschap is zeer heftig geweest</h2><p>De prijs van BTC is gedaald tot onder de $65.000, wat een aanzienlijke tegenslag betekent voor het marktsentiment.</p>
<p>ETH heeft zich aangepast rond $3.520 en heeft nog geen duidelijke tekenen van herstel laten zien.</p>
<p>De algehele daling van Altcoins heeft geleid tot een pessimistische marktsentiment. De twee nieuwe munten met een grote marktkapitalisatie, LISTA en ZRO, werden gisteren gelanceerd en trokken een groot bedrag aan fondsen aan, wat leidde tot ernstige marktzuiging.</p>
<h3 id="h3-Macroeconomische20aspecten800082"><a name="Macroeconomische aspecten:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomische aspecten:</h3><p>De Amerikaanse aandelenmarkt had een lichte terugval en deze vrijdag is de kwartaaloptie-vervaldag, die mogelijk verdere gevolgen kan hebben voor de markt.</p>
<h3 id="h3-Markt20hotspots761679"><a name="Markt hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt hotspots:</h3><p><strong>Cross-chain bridge protocol Laag Nul</strong><br>ZRO: De token van dit protocol, ZRO, werd gisteravond gelanceerd op belangrijke handelsplatforms en wordt momenteel geprijsd op $335 met een marktwaarde van $3.35 miljard.</p>
<p>Airdrop claim mechanism: Gebruikers moeten tokens doneren om ZRO airdrops te claimen. Voor elke ZRO die ze ontvangen, moeten ze een token ter waarde van $0,1 doneren aan Protocol Guild.</p>
<p><strong>AI Concept Tokens</strong><br>AI-concept tokens zoals ARKM en WLD blijven herstellen. Technologieaandelen zoals Nvidia hebben sterk gepresteerd, wat speculatie heeft opgewekt onder speculatieve beleggers over AI-narratieve tokens in het cryptoveld.</p>
<p><strong>Meme Sector</strong><br>Meme tokens zoals Cat POPCAT en Frog TURBO hebben een stijging gezien.</p>
<p>Nieuwe Memes gelanceerd op Solana Chain: Vanmorgen vroeg werd de Meme-token KITSUNE gelanceerd, die in korte tijd vertienvoudigde, maar vervolgens terugviel naar het startpunt van de stijging. KITSUNE was de eerste vos Meme-munt.</p>
<p>Algemene markt: De Memesector heeft de algemene prestaties van de markt gevolgd en vertoont een daling.</p>
<p>De huidige markt bevindt zich in een fase van aanzienlijke volatiliteit en investeerders moeten voorzichtig te werk gaan:</p>
<p>De trends van BTC en ETH zijn nog niet duidelijk, en het wordt aanbevolen om de belangrijkste ondersteunings- en weerstandsniveaus nauwlettend in de gaten te houden.</p>
<p>De lancering van de ZRO-token voor het Cross-Chain Bridge Protocol Layer Zero heeft de aandacht van de markt getrokken. Maar het inzamelingsmechanisme voor de airdrop is uniek en klachten van de gemeenschap zijn vrij gebruikelijk.</p>
<p>De prestaties van technologische aandelen stimuleren het AI-concept-token en kunnen op korte termijn blijven worden gehypet door speculatieve fondsen.</p>
<p>Hoewel de Meme-sector korte termijn pieken heeft meegemaakt, is de algehele prestatie ervan onstabiel en moeten investeerders zich richten op risicobeheer.</p>
<p>In de huidige marktomgeving moeten investeerders kalm blijven, de markttrends nauwlettend volgen, activa redelijk toewijzen en het blindelings najagen van hoge prijzen vermijden.</p>
<h2 id="h2-Macro20getrokken20door20chipleveranciers20en20economische20gegevens20bereikte20de20SampP2050020een20historisch20hoogtepunt20en20viel20toen20terug20Aziatische20aandelenmarkten20sloten20laag835188"><a name="Macro: getrokken door chipleveranciers en economische gegevens, bereikte de S&amp;P 500 een historisch hoogtepunt en viel toen terug; Aziatische aandelenmarkten sloten laag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: getrokken door chipleveranciers en economische gegevens, bereikte de S&amp;P 500 een historisch hoogtepunt en viel toen terug; Aziatische aandelenmarkten sloten laag</h2><p>Op 20 juni sloten de S&amp;P 500 en Nasdaq-indexen lager in de handel op donderdag. Marktleider Nvidia daalde nadat het ‘s ochtends was gestegen, omdat investeerders de laatste economische gegevens en opmerkingen van functionarissen van de Federal Reserve ueren om te bepalen of de rentetarieven dit jaar zullen worden verlaagd.</p>
<p>Specifieke indices: de Dow Jones-index steeg met 0,77%, de S&amp;P 500-index daalde met 0,25%, en de Nasdaq-index daalde met 0,79%.</p>
<p>Eerder bereikte de S&amp;P 500-index voor het eerst de cruciale 5.500-punten grens en meerdere effectenbedrijven voorspelden dat de index dit doel tegen het einde van het jaar zou bereiken. De Nasdaq beëindigde zijn record van zeven opeenvolgende handelsdagen en bereikte een nieuwe slotkoers.</p>
<p>De aandelenkoers van Nvidia daalde met 3,54% na een eerdere stijging. Deze chipfabrikant heeft op dinsdag Microsoft ingehaald als het meest waardevolle beursgenoteerde bedrijf, maar nu heeft Microsoft deze positie herwonnen.</p>
<p><strong>Aziatische aandelenmarkten sloten deze week laag af, met een zwakke yen-trend</strong><br>Op 21 juni namen Aziatische aandelenmarkten winstnemingen nadat ze eerder deze week een hoogtepunt van 26 maanden hadden bereikt, met een teleurstellende afsluitende prestatie. De renteverlaging van de Europese Centrale Bank heeft de Amerikaanse dollar versterkt, waardoor de yen verder wordt onderdrukt en het niveau van mogelijke interventie door de Japanse autoriteiten wordt benaderd.</p>
<p>De MSCI Asia Pacific aandelenindex werd beïnvloed door een terugtrekking van technologie-aandelen en daalde met 0,05% op vrijdag, in navolging van de trend op de aandelenmarkt van Wall Street ‘s nachts. De Nikkei-index in Japan daalde met 0,02%. De Chinese aandelenmarkt bleef grotendeels onveranderd, waarbij de Shanghai Composite Index een belangrijk niveau boven de 3000 punten handhaafde. De Hang Seng-index in Hong Kong daalde met 0,9%.</p>
<p>Bij de overnachthandel heeft de Zwitserse centrale bank opnieuw de rente verlaagd, terwijl de Bank of England ruimte vrijmaakte voor het versoepelingsbeleid van augustus na handhaving van ongewijzigde rentetarieven. Het pond, de Zwitserse frank en de euro daalden allemaal, terwijl de Amerikaanse dollar over het algemeen sterker werd.</p>
<p>Vanwege het versnelde tempo van renteverlagingen in Europa daalde de wisselkoers van de euro / Amerikaanse dollar met 0,4% naar $1,0705; de wisselkoers van het pond ten opzichte van de dollar bleef onveranderd op $1,2658, het laagste niveau in vijf maanden. De Japanse yen daalde met 0,1% naar 159,01, het laagste niveau sinds de Japanse autoriteiten eind april ingrepen op de markt.</p>
<p>Wat betreft grondstoffen, veerden de olieprijzen op vrijdag op na eerder deze week een zeven weken hoogtepunt te hebben bereikt. Brent ruwe olie futures daalden met 0,1% naar $85,59 per vat, terwijl Amerikaanse ruwe olie futures met 0,1% daalden naar $81,19 per vat.</p>
<p>De prijs van goud bleef onveranderd op $2.358,83 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 beleggingsaanbevelingen.<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 zullen juridische stappen worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>