RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0by1tYXJrdCBzdGlqZ3QsIE1lbWUgaXMgc3Rlcms7IFRydW1wIHZlcmtsYWFyZGUgZGF0ICJkZSBWUyBkZSBsZWlkZXIgbW9ldCB3b3JkZW4gaW4gY3J5cHRvJ3MiOyBEZXBvc2l0bydzIGVuIFRWTCB2YW4gRXRoZXIuZmkgemlqbiBuYWFyIGhpc3RvcmlzY2hlIGhvb2d0ZXB1bnRlbiBnZXN0ZWd

2024-05-27, 03:40

<p><img src="https://gimg2.gateimg.com/image/article/17167809821_17.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Trump20verklaarde20tijdens20zijn20campagne20dat20de20Verenigde20Staten20de20leider20zou20moeten20worden20in20cryptocurrencies20Depositos20en20TVL20van20Etherfi20zijn20naar20historische20hoogtepunten20gestegen20Solana20is20van20plan20om20Firedance20te20lanceren20in202025997303"><a name="Crypto Dagelijkse Samenvatting: Trump verklaarde tijdens zijn campagne dat “de Verenigde Staten de leider zou moeten worden in cryptocurrencies.”; Deposito’s en TVL van Ether.fi zijn naar historische hoogtepunten gestegen; Solana is van plan om Firedance te lanceren in 2025." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: Trump verklaarde tijdens zijn campagne dat “de Verenigde Staten de leider zou moeten worden in cryptocurrencies.”; Deposito’s en TVL van Ether.fi zijn naar historische hoogtepunten gestegen; <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> is van plan om Firedance te lanceren in 2025.</h2><p>Laten we eerst eens kijken naar de handelsactiviteiten van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor bedroeg de instroom van Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) op 24 mei $4.370, de instroom van IShares Trust Bitwise Bitcoin spot ETF (IBIT) was $182,1 miljoen, de instroom van Bitcoin spot ETF (BITB) was $6,4 miljoen, de instroom van ARK 21Shares Bitcoin spot ETF (ARKB) was $4,1 miljoen.</p>
<p>In een bericht dat op 25 mei werd geplaatst op TruthSocial, een sociaalmediaplatform onder de Trump Media and Technology Group (TMTG), verklaarde Trump: “Ons land moet een leider worden op dit gebied, er is geen tweede plaats.”</p>
<p>Hij beweerde: “Ik heb een zeer positieve en open houding ten opzichte van cryptobedrijven en alles wat met deze opkomende industrie te maken heeft.” Later wees hij met de vinger naar de huidige president Joe Biden. Eerder kondigde Trump aan dat zijn presidentscampagne crypto-donaties zou accepteren. Op 21 mei kondigde het Trump 2024-campagneteam aan dat de inzamelingspagina was gelanceerd.</p>
<p>Volgens het New Yorkse cryptovoorspellingsplatform Polymarket is de kans dat Trump de verkiezingen wint 56%, terwijl de kans op de huidige president Joe Biden 38% is. Volgens CoinGecko-gegevens is de Trump-thematische Meme-munt MAGA (TRUMP) gestegen tot $12 en wordt nu verhandeld op $12.63, met een stijging van 36.5% in de afgelopen 24 uur.</p>
<p><strong>Na de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Nadat de spot ETF is goedgekeurd, is de storting en totale waarde opgesloten (TVL) van Ether.fi naar historische hoogten gestegen.</strong><br>Als gevolg van de verwachtingen van beleggers dat de Verenigde Staten spot <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (ETH) exchange traded funds (ETF’s) zal goedkeuren, zijn de stortingen en de totale waarde vergrendeld (TVL) van het opnieuw staken protocol Ether.fi gestegen naar historische hoogtepunten.</p>
<p>Re-staken is een strategie die door handelaren wordt gebruikt om extra winst te verdienen uit Ethereum-munten die al zijn gestaked op de Ethereum-blockchain. Ether.fi biedt momenteel een jaarrendement van 3,48%, met een extra 15,1% van het rendement beschikbaar via de liquide schatkist van het product.</p>
<p>In de afgelopen tien dagen is er meer dan 270.000 ETH ($995 miljoen) gestort in Ether.fi. Volgens de gegevens van DefiLlama heeft de instroom van deze fondsen, in combinatie met de recente stijging van de Ethereum-prijzen, de totale vergrendelingswaarde van het protocol verhoogd van $4 miljard tot $5,4 miljard, wat een historisch hoogtepunt heeft bereikt.</p>
<p><strong>Met de toename van DePIN-activiteiten, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> plannen om Firedance te lanceren in 2025</strong><br>Kuleen Nimkar, hoofd van DePIN bij de Solana Foundation, verklaarde dat Solana van plan is om een volledige versie van de Firedance-upgrade uit te brengen in 2025 en een ‘Lite Edition’ daarvoor.</p>
<p>Met de toenemende netwerkactiviteit van gedecentraliseerde infrastructuurprotocollen heeft deze upgrade tot doel de algehele betrouwbaarheid en schaalbaarheid van Solana te verbeteren. Kuleen noemde de DePIN-campagne op DEFICON op 23 mei: “We zien een groot aantal opkomende diepe projecten die van alles doen.”</p>
<p>Kuleen zei: De DePIN-gebruiksscenario’s in het Solana-ecosysteem variëren van protocollen die zijn gewijd aan gedecentraliseerde energieoplossingen (huiseigenaren die onderling verbonden virtuele energiecentrales creëren) tot GPU-netwerken en gegevensverzameling. Sommige projecten moedigen bijvoorbeeld gebruikers aan om browserextensies te installeren om het internet af te struinen en gegevens te verzamelen om grote taalmodellen te trainen.</p>
<p>De protocollen voor het overdragen van DePIN-activiteiten naar Solana omvatten <a href="/price/helium-hnt" rel="nofollow noopener noreferrer" target="_blank">Helium</a> Hivemapper en <a href="/price/render-rndr" rel="nofollow noopener noreferrer" target="_blank">Render</a>. Volgens Dune Analytics is het aantal Hivemapper mappers in 2024 sterk gestegen, van ongeveer 30.000 verbonden bestuurders in mei tot bijna 67.000.</p>
<h2 id="h2-Markttrends20De20markt20fluctueert20omhoog20het20Memeconcept20leidt20de20markt194733"><a name="Markttrends: De markt fluctueert omhoog, het Meme-concept leidt de markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt fluctueert omhoog, het Meme-concept leidt de markt</h2><p>Uit de huidige markttrends en hotspots is gebleken dat de cryptomarkt afgelopen weekend een zekere stijgende trend heeft laten zien. BTC heeft opnieuw de $69.000 doorbroken, ETH nadert ook de $3.900, wat wijst op een volatiele stijgende trend in de algehele markt. De BTC-dominantie is echter gedaald tot 52,7%, wat een signaal kan zijn van het begin van het Altseason. In deze context kunnen beleggers meer aandacht besteden aan Altcoins en opkomende projecten.</p>
<p>Daarnaast heeft de stijging van Amerikaanse aandelen, met name de versterking van technologieaandelen, ook een zeker positief effect op de cryptomarkt. Nvidia presteerde vorige week veel beter dan verwacht, wat de hele technologiesector heeft doen stijgen en mogelijk indirect enig vertrouwen in de cryptomarkt heeft geïnjecteerd.</p>
<h3 id="h3-Markt20Hotspots485155"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>Tokens gebaseerd op Ethereum</strong><br>ENS ( <a href="/price/ethereum-name-service-ens" rel="nofollow noopener noreferrer" target="_blank">Ethereum Naamservice</a>): De ENS-token is onlangs gestegen en heeft meerdere goedkeuringen ontvangen van de oprichter van Ethereum, Vitalik Buterin. Vitalik Buterin is van mening dat ENS een belangrijk hulpmiddel is voor het verenigen van verschillende Layer2-netwerken in Ethereum. Deze erkenning verhoogt ongetwijfeld de markt aantrekkelijkheid van ENS.</p>
<p>PEPE en TURBO: Deze twee Frog Meme-tokens hebben het goed gedaan op de Ethereum-chain en hebben recentelijk historische hoogtepunten bereikt. De toenemende interesse van investeerders in deze tokens heeft de prijzen opgedreven.</p>
<p>MAGA: Deze token, vernoemd naar Trump’s campagneslogan, is meer dan 10 keer gestegen sinds de lancering op Gate.io, wat wijst op een sterke interesse in tokens met actuele en merkeffecten op de markt.</p>
<p><strong>Andere Meme Munten</strong><br>PENG en PONKE: Deze twee tokens presteerden even goed in het weekend. PENG is met 200% gestegen vanaf het dieptepunt halverwege de maand, en PONKE is sinds de notering op Gate.io met 10 keer toegenomen. Dit toont de markt’s streven naar opkomende Meme coins.</p>
<p><strong>Nieuwe munten</strong><br>BB, REZ, OMNI: Deze nieuwe munten hebben een relatief kleine marktwaarde, een goede chipstructuur en kunnen gemakkelijk omhoog getrokken worden. Dit biedt investeerders de mogelijkheid voor hoogrisico en hoog rendement investeringen.</p>
<p><strong>Token Ontgrendelen</strong><br>ENA zal deze week $50 miljoen aan tokens vrijgeven, wat kan leiden tot verhoogde marktvolatiliteit. Beleggers moeten voorzichtig zijn met prijsschommelingen vóór en na het vrijgeven van de tokens.</p>
<p>Met de daling van de BTC-dominantie kan het Altcoin-seizoen zijn begonnen, en gebruikers kunnen overwegen hun investeringen te diversifiëren in BTC ETH en enkele potentiële Altcoins om het risico te verminderen. Richt je op ENS Recentelijk opvallende tokens zoals PEPE en TURBO hebben het goed gedaan. Kortom, de algehele markt verbetert momenteel, maar investeerders moeten waakzaam blijven, aandacht besteden aan markthotspots en macro-economische veranderingen, en flexibel investeringsstrategieën aanpassen.</p>
<h2 id="h2-Macro20Amerikaanse20aandelen20sloten20hoger20waarbij20de20Nasdaq20een20nieuw20hoogtepunt20bereikte20Aziatische20aandelenmarkten20stegen20lichtjes571273"><a name="Macro: Amerikaanse aandelen sloten hoger, waarbij de Nasdaq een nieuw hoogtepunt bereikte; Aziatische aandelenmarkten stegen lichtjes." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse aandelen sloten hoger, waarbij de Nasdaq een nieuw hoogtepunt bereikte; Aziatische aandelenmarkten stegen lichtjes.</h2><p>Op vrijdag herstelde de Amerikaanse aandelenmarkt zich van de scherpe daling van de vorige dag, gedreven door nieuws over verbeterde inflatievooruitzichten van consumenten. De Nasdaq-index steeg voor de vijfde opeenvolgende week en bereikte een nieuwe slotkoers hoog.</p>
<p>De prestaties van de index zijn als volgt: de Dow Jones-index steeg met 0.01%, de S&amp;P-index steeg met 0.7% en de Nasdaq-index steeg met 1.1%.</p>
<p>Het Amerikaanse ministerie van Handel verklaarde dat nieuwe orders voor belangrijke vervaardigde kapitaalgoederen in de VS in april sterker herstelden dan verwacht. Ondertussen toont een rapport van de Universiteit van Michigan aan dat de consumentenverwachtingen voor inflatie zijn verbeterd na een verslechtering aan het begin van de maand.</p>
<p>Op vrijdag zal de Federal Reserve kerngegevens over persoonlijke consumptie-uitgaven (PCE) publiceren, wat een van de voorkeursindicatoren is voor het meten van inflatie. Er wordt verwacht dat de inflatie in april met 0,3% zal stijgen, met een jaarlijkse rente van 2,8%, maar er is een neerwaarts risico.</p>
<p>De FedWatch-tool van de Chicago Mercantile Exchange laat zien dat de markt een kans van 49,4% verwacht dat de Federal Reserve de rente verlaagt tijdens zijn vergadering in september, in vergelijking met 54,8% een week geleden. Goldman Sachs heeft zijn eerste renteverlaging uitgesteld van juli naar september.</p>
<p>Vorige week bereikte Nvidia een historisch hoogtepunt. Sterker nog, Nvidia alleen al droeg een kwart bij aan de stijging van de S&amp;P 500-index tot nu toe dit jaar, terwijl de top zeven technologiebedrijven dit jaar een stijging van 24% hebben gezien.</p>
<p><strong>Voor de inflatietest stegen Aziatische aandelenmarkten lichtjes</strong><br>Op maandag stegen Aziatische aandelenmarkten lichtjes, terwijl beleggers wachtten op het belangrijke Amerikaanse inflatierapport deze week, dat de basis kan leggen voor renteverlagingen in de VS.</p>
<p>De MSCI Asia Pacific-aandelenindex daalde vorige week met 1,5%, ver verwijderd van het hoogste punt in twee jaar. De Nikkei-index in Japan steeg met 0,26%. Volgens gegevens van het Nationaal Bureau voor de Statistiek van China zijn de winsten van industriële ondernemingen boven een aangewezen omvang in China in de eerste vier maanden van dit jaar met 4,3% op jaarbasis gestegen.</p>
<p>Wat betreft de valutamarkt ligt de focus opnieuw op het risico van Japanse interventie in de wisselkoers van de yen voordat het niveau van 160,00 wordt bereikt. De wisselkoers tussen de Amerikaanse dollar en de Japanse yen was vorige week 156,89, een stijging van 0,9%. De gouverneur en vicegouverneur van de Bank of Japan, evenals de hoofdeconoom van de Europese Centrale Bank, zullen later op maandag toespraken houden. De Bank of Japan zal op 14 juni een beleidsvergadering houden, die mogelijk de wereldwijde trend zal omkeren en de rente opnieuw zal verhogen, hoewel de renteverhoging slechts 0,15% bedraagt.</p>
<p>Op het gebied van grondstoffen is het piekrijseizoen in de Verenigde Staten deze week begonnen, en zorgen over de vraag hebben ertoe geleid dat de olieprijzen rond een dieptepunt van vier maanden zweven. Beleggers kijken of OPEC+ op 2 juni tijdens zijn online vergadering nieuwe productieverlagingsmaatregelen zal bespreken, maar analisten betwijfelen of hierover consensus zal worden bereikt.</p>
<p>De prijzen van Brent ruwe olie stegen met $0.05 naar $82.17 per vat, terwijl de prijzen van Amerikaanse ruwe olie met 9 cent stegen naar $77.81 per vat.</p>
<p>De prijs van goud bleef op $2,337 per ounce, 3,4% lager vorige week.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel te herposten mits Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>