RGFnZWxpamtzIG5pZXV3cyB8IEVUSC1rb3N0ZW4gYmVyZWlrdGVuIGluIGZhc2VuIGVlbiBuaWV1dyBkaWVwdGVwdW50LCBtZXQgZWVuIHN0ZXJrZSBFVEgtZWNvc3lzdGVlbTsgV2ViMy1wb3J0YWFsIGdlbGFuY2VlcmQgZG9vciBHb29nbGUgQ2xvdWQgdmVyb29yemFha3RlIGNvbnRyb3ZlcnNlIGluIGRlIGNyeXB0by1pbmR1c3RyaWU

2024-04-29, 04:25

<p><img src="https://gimg2.gateimg.com/image/article/171436461129.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20Ethereum20kosten20zijn20verlaagd20tot20het20laagste20niveau20in20620maanden20het20Altcoinseizoen20kan20worden20versneld20Het20Web3portaal20gelanceerd20door20Google20Cloud20heeft20controverse20veroorzaakt20in20de20cryptoindustrie43786"><a name="Crypto Dagelijkse Samenvatting: Ethereum kosten zijn verlaagd tot het laagste niveau in 6 maanden, het ‘Altcoin-seizoen’ kan worden versneld; Het Web3-portaal gelanceerd door Google Cloud heeft controverse veroorzaakt in de crypto-industrie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> kosten zijn verlaagd tot het laagste niveau in 6 maanden, het ‘Altcoin-seizoen’ kan worden versneld; Het Web3-portaal gelanceerd door Google Cloud heeft controverse veroorzaakt in de crypto-industrie</h2><p>Laten we eerst eens kijken naar de handelsactiviteit van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF’s. Volgens gegevens van Farside Investor stroomden op 26 april (afgelopen vrijdag) fondsen van Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (GBTC) uit voor $82,4 miljoen; Ondertussen stroomt Fidelity Bitcoin spot ETF (FBTC) uit voor $2,8 miljoen, Bitwise Bitcoin spot ETF (BITB) uit voor $3,8 miljoen, ARK 21Shares Bitcoin spot ETF (ARKB) instroomt voor $5,4 miljoen en WisdomTree Bitcoin spot ETF (BTCW) netto instroomt van $6,6 miljoen.</p>
<p>De afname van transactievolume en het ontgrendelen van tokens op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het netwerk heeft geleid tot een tijdelijk lage netwerkkosten; de prijs van ETH wordt momenteel gemeld op $3.223,53, met een stijging van 2,6% in 7 dagen. Ondanks de stijging van de Ethereum-prijzen zijn de transactiekosten op het Ethereum-netwerk gedaald naar een dieptepunt van zes maanden. Analisten van het cryptografische analyseplatform Santiment suggereren dat dit erop kan wijzen dat Altcoins zullen stijgen.</p>
<p>Vanaf 27 april is de gemiddelde kosten van Ethereum-transacties gedaald tot $1,12. Santiment gelooft: ‘Handelaren zweven altijd tussen het gevoel dat cryptocurrencies op het punt staan om ‘naar de maan te gaan’ en bearish sentiment cycli, wat kan worden waargenomen aan de hand van handelskosten.’</p>
<p>Volgens de gegevens van Ultrasound.money zijn er in de afgelopen 30 dagen 74.458 nieuwe ETH’s uitgegeven, terwijl er slechts 57.516 ETH’s zijn vernietigd, wat de nettovoorraad van 16.979 nieuwe Ethereum heeft verhoogd.</p>
<p>Dit staat in schril contrast met de vorige vijf maanden, toen ETH bleef leeglopen. Ondanks de recente toename van op ETH gebaseerde inflatie, zijn er sinds 15 september 2022 meer dan 437.000 ETH’s vernietigd, toen het internet zich richtte op de Proof of Stake-consensusmechanismen (bekend als ‘Merge’).</p>
<p>Google Cloud heeft onlangs een Web3-portal gelanceerd met testnet-tools, blockchain-datasets en ontwikkelaarsleerbronnen, maar de cryptobranche heeft hier verschillend op gereageerd.</p>
<p>Volgens zijn website kunnen ontwikkelaars verschillende producten gebruiken en testnet tokens ontvangen door hun gedecentraliseerde applicaties te implementeren en te testen op het Ethereum testnet Sepolia en Holesky. Het portaal biedt ook een leerplan aan met handleidingen voor het ontwikkelen van NFT’s, het implementeren van <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> loyaliteitsprogramma’s en het beschermen van digitale activa met behulp van multi-party berekening.</p>
<p>Onlangs heeft Google inderdaad enige vooruitgang geboekt in de Web3-industrie. Begin 2024 heeft Google zijn beleid bijgewerkt om bepaalde crypto-producten toe te staan om te adverteren op grote zoekmachines, waaronder Bitcoin Exchange Traded Funds. Onlangs heeft Google zijn functionaliteit uitgebreid om gebruikers in staat te stellen te zoeken naar wallet-balansen op meerdere blockchains, zoals Bitcoin, Arbitrum, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, en <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a>.</p>
<p>De token economie van het volgen van projecten is essentieel voor crypto-investeerders, en de verschillende tokens die in mei zijn vrijgegeven, zijn zeer opvallend, vooral het zeer gepubliceerde Python Network - Python, dat meer dan $1 miljard waard is, zal de eerste set tokens ontgrendelen voor ecosysteemdeelnemers binnen drie weken, tot 1,25 miljard.</p>
<p>Naast Python Network zijn er nog verschillende andere crypto-projecten die ook van plan zijn om tokens ter waarde van miljarden dollars vrij te geven. Volgens de gegevens van Token.Unlocks zijn dit enkele belangrijke tokens die in mei ontgrendeld zullen worden:</p>
<p>Memeland zal op 3 mei $150 miljoen aan Memecoins vrijgeven; <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> zal op 12 mei $100 miljoen aan APT’s ontgrendelen;</p>
<p>Arbitrum zal op 16 mei $100 miljoen aan ARBs ontgrendelen; <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> zal op 22 mei $325 miljoen aan AVAXs ontgrendelen; STRK (Starknet) zal op 15 mei 8,8% van zijn circulerende voorraad ontgrendelen.</p>
<h2 id="h2-Markttrends20De20markt20is20volatiel20en20het20ETHecosysteem20vertoont20sterke20prestaties3150"><a name="Markttrends: De markt is volatiel en het ETH-ecosysteem vertoont sterke prestaties." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De markt is volatiel en het ETH-ecosysteem vertoont sterke prestaties.</h2><p>BTC heeft de laatste tijd een volatiele trend laten zien, waarbij de focus van de markt voornamelijk ligt op het Ethereum-ecosysteem. Wat betreft de macro-economie is de Amerikaanse aandelenmarkt hersteld, met marktvoorspellingen voor een renteverlaging van 35 basispunten dit jaar en een verwachte grotere verlaging van 60 basispunten volgend jaar. Deze verandering in de macro-economische verwachting kan invloed hebben op de cryptomarkt, met name op de aantrekkelijkheid van risicovolle activa.</p>
<h3 id="h3-Markt20Hotspots844841"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Ethereumprijzen en markthype: ETH steeg gisteren en brak op een gegeven moment door de $3.300, terwijl de wisselkoers ETH/BTC ook de 0,05 doorbrak. De markt speculeert over de mogelijkheid dat ETH-spot-ETF’s eind mei worden goedgekeurd, wat de verwachtingen van de markt met betrekking tot de vraag naar ETH heeft vergroot.</p>
<p>De huidige handelsactiviteit op het ETH-netwerk is echter niet actief, wat zich uit in lagere gasvergoedingen, wat erop kan wijzen dat speculatieve aankopen meer invloed hebben op de korte termijn prijsstijging.</p>
<p>Het Ethereum-ecosysteem heeft een uitstekende prestatie laten zien in gerelateerde projecten: Ethereum-gerelateerde herstakingprotocollen, zoals SSV en ETHFI, hebben prijsstijgingen laten zien. Tegelijkertijd hebben Ethereum’s Layer2-protocollen, zoals <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> (OP) en Strike (STRK), ook prijsstijgingen aangetoond. Het is met name opmerkelijk dat deze week de OP tokens ter waarde van $60 miljoen zal ontgrendelen, wat van invloed kan zijn op hun marktprijzen.</p>
<p>De opkomst van het concept van storting: Deposition sector tokens zoals HNT en MOBILE hebben aanzienlijke prijsstijgingen laten zien. Bovendien hebben de eerder uitgebrachte <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Gebaseerde SAGA-telefoons hebben een rendement op investering behaald via Meme-token airdrops, wat het marktinteresse en investeringspotentieel in Depin en gerelateerde technologieën aantoont.</p>
<p>Met de marktverwachtingen voor ETH-spot ETF’s en voortdurende aandacht voor het Ethereum-ecosysteem, in combinatie met positieve macro-economische verwachtingen, kan de cryptomarkt de komende weken volatiel blijven. Beleggers moeten nauwlettend de relevante beleidstrends, marktontsluitingsevenementen en on-chain gegevens in de gaten houden, die allemaal van invloed kunnen zijn op het marktsentiment en de tokenprijzen. Beleggers wordt geadviseerd om voorzichtig te blijven, aandacht te besteden aan markttrends en tijdig hun beleggingsstrategieën aan te passen om mogelijk marktschommelingen aan te kunnen.</p>
<h2 id="h2-Macro20De20prestaties20van20de20Amerikaanse20aandelenmarkt20waren20lager20dan20verwacht20terwijl20de20Aziatische20markt20goed20opende20op20maandag20De20wisselkoers20van20de20Japanse20yen20daalde20onder20een20kritisch20niveau42758"><a name="Macro: De prestaties van de Amerikaanse aandelenmarkt waren lager dan verwacht, terwijl de Aziatische markt goed opende op maandag. De wisselkoers van de Japanse yen daalde onder een kritisch niveau" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De prestaties van de Amerikaanse aandelenmarkt waren lager dan verwacht, terwijl de Aziatische markt goed opende op maandag. De wisselkoers van de Japanse yen daalde onder een kritisch niveau</h2><p>Afgelopen vrijdag, 26 april, teleurstelde de overwaardering van de Amerikaanse aandelenmarkt investeerders, vooral omdat verschillende tech-giganten hun investeringsinspanningen verhoogden voordat ze hun financiële rapporten publiceerden.</p>
<p>De sterke rapporten van Microsoft en het moederbedrijf van Google, Alphabet, op donderdag hebben de S&amp;P 500-index doen stijgen, de grootste wekelijkse stijging sinds begin november vorig jaar. De S&amp;P 500-index steeg ongeveer 7% in 2024 en ongeveer 24% sinds het einde van oktober vorig jaar.</p>
<p>Echter werden investeerders ook getroffen door de teleurstellende prestaties van het moederbedrijf van Facebook, Meta Platforms, waarvan de aandelenkoers op donderdag met meer dan 10% daalde.</p>
<p>De strateeg van Morgan Stanley verklaarde dat de gemiddelde aandelenprijs van bedrijven in de S&amp;P 500-index voor dit kwartaal slechts 0,2% hoger was dan de verwachtingen van analisten. Daarentegen daalden de gemiddelde aandelenprijzen van bedrijven die niet aan de winstverwachtingen voldeden met 4%, wat duidt op slechte prestaties.</p>
<p>De stijging van de rendementen op Amerikaanse schatkistobligaties kan een andere factor zijn die beleggers beïnvloedt. Wanneer de obligatierendementen stijgen, zullen de verwachtingen van beleggers ten aanzien van toekomstige winsten voor het bedrijf worden beïnvloed, aangezien zij nu hogere rendementen kunnen behalen uit risicovrije staatsobligaties. Met meer bewijs dat de inflatie sterker is dan verwacht, bereikte het rendement op de 10-jarige staatsobligatie deze week 4,74%, het hoogste niveau sinds begin november vorig jaar.</p>
<p>Nu er tekenen van economische kracht en inflatie opduiken, is de verwachting van renteverlagingen de belangrijkste drijvende kracht geweest achter de stijging van de aandelenmarkt, maar deze verwachting is vervaagd. De futuresmarkt liet vrijdag zien dat beleggers slechts een verwachting van 35 basispunten hadden voor een renteverlaging in 2024, terwijl de prijzen in januari meer dan 150 basispunten bedroegen.</p>
<p>Voorafgaand aan de beleidsvergadering van de Federal Reserve later deze week openden de Aziatische aandelenmarkten goed op maandag. De Aziatische aandelenmarkt werd op maandag gestimuleerd door de stijging van de Wall Street-aandelen, geleid door technologie-aandelen op vrijdag.</p>
<p>Op vrijdag heeft de Bank of Japan zoals verwacht de rentetarieven ongewijzigd gelaten, maar heeft geen betekenisvolle zorgen geuit over de wisselkoers. De yen-dollar wisselkoers daalde op vrijdag naar 157,79, een nieuw dieptepunt in 34 jaar, en voor het eerst in decennia brak de dollar ten opzichte van de yen door een psychologisch kritisch niveau van 160 yen, zij het slechts kortstondig. De meeste waarnemers verwachten nu dat Tokyo actie onderneemt - aangezien de laatste interventie in september en oktober 2022 was, toen de USD-wisselkoers respectievelijk rond 146,00 en 152,00 yen was.</p>
<p>Andere Aziatische landen worden ook steeds ongemakkelijker over wisselkoersen. Indonesië heeft de rente verhoogd om de zwakte van roepia te compenseren, terwijl Vietnam en India rechtstreeks hebben ingegrepen op de valutamarkt om hun eigen valuta te kopen. Zuid-Korea heeft ook verklaard dat het hetzelfde zal doen.</p>
<p>Over het algemeen kan het beleidsbesluit van de Federal Reserve op woensdag ervoor zorgen dat de forex en andere markten de komende dagen voorzichtig blijven. De focus van de Aziatische economische kalender van deze week omvat de China Purchasing Managers Index, notulen van de vergadering van de Bank of Korea, inflatie in Zuid-Korea en Indonesië, en het bbp van Hong Kong.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen met 1% gedaald als gevolg van de impact van staakt-het-vuren besprekingen tussen Israël en Hamas, evenals inflatiezorgen in de Verenigde Staten. Brent ruwe olie futures daalden met 1,1% naar $88,50 per vat, terwijl West Texas Intermediate (WTI) futures met 1% daalden naar $83,01 per vat.</p>
<p>De wereldwijde benchmarkprijs voor Brent ruwe olie is grotendeels onveranderd gebleven ten opzichte van dezelfde periode vorig jaar, op $81,76 per vat. Maar de stijging van de olieprijzen betekent dat winstgevende raffinagemarges vanaf het begin van dit jaar zullen afnemen. Total Energies verwacht dat zijn raffinageactiviteiten in het tweede kwartaal en daarna minder winstgevend zullen zijn als gevolg van geopolitieke spanningen en productiebeperkingen van OPEC+.</p>
<p>Goud daalde met 0,34% tot $2.329,37 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 standpunten van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herposten van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>