RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0by1tYXJrdCBibGlqZnQgc3RpamdlbjsgV0xEIHdvcmR0IHZvbGdlbmRlIHdlZWsgb250Z3JlbmRlbGQsIG1ldCBlZW4gcHJpanNzdGlqZ2luZyB2YW4gMjAlOyBCbGFzdCBrb25kaWdkZSBlZW4gdmVybGFnaW5nIHZhbiBkZSBvcG5hbWV0aWpkIGFhbg==

2024-07-17, 04:09

<p><img src="https://gimg2.gateimg.com/image/article/17211891921_14.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20cryptomarkt20blijft20zich20herstellen20De20Worldcointoken20wordt20volgende20week20ontgrendeld20met20een20prijsstijging20van202020Blast20kondigde20een20verlaging20van20de20opnametijd20aan452548"><a name="Crypto Dagelijkse Samenvatting: De cryptomarkt blijft zich herstellen; De Worldcoin-token wordt volgende week ontgrendeld, met een prijsstijging van 20%; Blast kondigde een verlaging van de opnametijd aan" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De cryptomarkt blijft zich herstellen; De Worldcoin-token wordt volgende week ontgrendeld, met een prijsstijging van 20%; Blast kondigde een verlaging van de opnametijd aan</h2><p>Eerst gaan we de handelsactiviteit van de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Volgens de gegevens van Farside Investor had de Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) op 16 juli een fondsafvloeiing van $28,6 miljoen. Ondertussen ontving de Fidelity Bitcoin Spot ETF (FBTC) een instroom van $61,1 miljoen, ontving de Bitwise Bitcoin Spot ETF (BITB) een instroom van $17,3 miljoen en ontving de ARK 21 Shares Bitcoin Spot ETF (ARKB) een instroom van $29,8 miljoen.</p>
<p>BTC blijft sterk stijgen en breekt vanochtend door de $66.000 heen. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> (ETH) steeg boven de $3.500, en er wordt gemeld dat het <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> spot ETF op 23 juli zal beginnen met handelen - bronnen van twee Amerikaanse uitgevers hebben dit bevestigd aan The Block. Bloomberg senior ETF-analist Eric Balchunas plaatste dit nieuws ook op het socialemediaplatform X. Enkele weken geleden heeft de Amerikaanse Securities and Exchange Commission (SEC) begin mei zachte goedkeuring verleend aan uitgevers.</p>
<p>Analisten van Presto Research verklaarden in het marktrapport van dinsdag: “Hoewel ETH waarschijnlijk niet BTC zal overtreffen op het eerste punt, gezien het feit dat de handel in spot ETF waarschijnlijk op 23 juli zal beginnen, kan ETH BTC inhalen op institutioneel gebied vanaf volgende week.”</p>
<p>Het onderzoeksbureau voorspelt dat op korte termijn de ETH/BTC-verhouding kan terugkeren naar het niveau dat werd vastgelegd toen de Amerikaanse Securities and Exchange Commission voor het eerst de 19b-4-formulier goedkeurde voor spot Ethereum ETF’s in het midden van mei. De analist voegde eraan toe: ‘Op de lange termijn betekent het herstellen van de ETH/BTC-verhouding naar het niveau van de bullmarktcyclus van 2021 een groter opwaarts potentieel’.</p>
<p>Volgens het laatste rapport van Kaiko kan Ethereum na de langverwachte lancering van de Ethereum Exchange Traded Fund (ETF) in de Verenigde Staten beter presteren dan Bitcoin.</p>
<p><strong>Worldcoin-token wordt volgende week ontgrendeld, met een prijsstijging van 20%</strong></p>
<p>Worldcoin, een handmatig geverifieerd cryptoproject mede-opgericht door OpenAI CEO Sam Altman, kondigde aan dat de vroege bijdragers aan het project vanaf volgende week hun tokens ontgrendeld zullen zien. Het project verklaarde in een blogbericht dat “het WLD-tokenprogramma toegewezen aan investeerders en teamleden van Tools for Humanity (TFH) (vroegtijdige bijdragers aan het Worldcoin-project) dagelijks op lineaire wijze zal beginnen te ontgrendelen.” Het ontgrendelingsschema voor 80% van WLD in handen van TFH-teamleden en investeerders zal verlengd worden van 3 jaar naar 5 jaar.</p>
<p>Tools for Humanity is de belangrijkste ontwikkelaar en belangrijkste supporter van het Worldcoin-project. Dit project kent wereldwijde ID’s en tokens toe aan degenen die bereid zijn oogscans te ondergaan om te bewijzen dat ze menselijk zijn. Investeerders en medewerkers van Tools for Humanity hebben vergrendelde WLD-tokens toegewezen gekregen om ‘hun respectievelijke bijdragen te weerspiegelen’.</p>
<p>Op het moment van schrijven is de WLD-token met meer dan 23,8% gestegen tot $2,83.</p>
<p><strong>Netwerkupdates van Blast naar volledige stack chain, waardoor de opnametijd wordt verkort</strong></p>
<p>Het Ethereum Layer 2 Blast-netwerk heeft de opnametijd gehalveerd, van 14 dagen naar 7 dagen. Het team plaatste dit bericht via hun nieuwe X-account @blast. Het vorige account @blast_12 kondigde het bestaan van een nieuw account aan in zijn profiel.</p>
<p>Zoals eerder gemeld, lanceerde Blast Network op 26 juni de eerste fase van de BLAST-token airdrop. De volgende dag steeg de waarde van de token met 40%. Vervolgens is de prijs van de token gedaald tot $ 0,017, iets onder de uitgifteprijs van $ 0,02.</p>
<p>Blast-kernbijdragers hebben de opnameactiviteit de afgelopen vier maanden gemonitord en hebben nu geconcludeerd dat ‘een kleinere buffer voldoende is om bijna alle opnameactiviteiten aan te kunnen’. Sommige opnames kunnen echter nog steeds meer dan zeven dagen duren, hoewel dit alleen in ‘zeer zeldzame glen gebeurt. Deposito’s van Ethereum naar Blast kunnen nog steeds in slechts een paar minuten worden verwerkt.</p>
<p>Sommige Blast-volgers hebben een verandering in de protocolnaam op X opgemerkt. Voormalige <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a> Contributor en X-gebruiker Jim speculeert dat dit betekent dat Blast niet langer de Layer 2 van Ethereum zal zijn. Blast veranderde zijn naam van @Blast_L2 naar @blast en noemt zichzelf nu de ‘full stack chain’, “zei hij.</p>
<h2 id="h2-Markttrends20BTCspotETFs20blijven20grote20instromen20ontvangen20en20de20markt20blijft20scherp20stijgen599908"><a name="Markttrends: BTC-spot-ETF’s blijven grote instromen ontvangen, en de markt blijft scherp stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: BTC-spot-ETF’s blijven grote instromen ontvangen, en de markt blijft scherp stijgen</h2><p><strong>BTC:</strong><br>Na een korte terugval tot ongeveer $62.500 gisteren, steeg BTC sterk door en brak vanochtend door $66.000 heen. Op dit moment blijven spot ETF’s $160 miljoen instromen (exclusief IBTC-gegevens voorlopig).<br><strong><br>ETH:</strong><br>ETH steeg boven $3.500 en de verwachtingen voor spot ETF’s stimuleren de marktprestaties van ETH.</p>
<p><strong>Altcoin:</strong><br>Altcoins zijn over het algemeen gestegen, waarbij de Meme-sector de markt aanvoert.</p>
<p><strong>Gegevensindicatoren:</strong><br>AHR999 Index: Vandaag is het 0.88, en de markt heeft de bodemzone gepasseerd.</p>
<p>Angst Gierigheidsindex: 69, iets hoger dan gisteren, het marktsentiment is aanzienlijk verbeterd en begint zelfs de hebzuchtzone binnen te gaan.</p>
<h3 id="h3-Macroeconomie208538"><a name="Macroeconomie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie</h3><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten gezamenlijk hoger af, waarbij Trump verklaarde dat hij Powell niet vroegtijdig zou vervangen als hij tot president werd gekozen. Volgens de analyse van Moody’s suggereert de Federal Reserve dat de rentetarieven in juli met 25 basispunten zullen worden verlaagd, met een cumulatieve verlaging van 50-75 basispunten gedurende het jaar, en een extra verlaging van 100-125 basispunten tegen 2025.</p>
<h3 id="h3-Markt20Hotspots248805"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><strong>Polifi Concept:</strong><br>FIGHT Token: Het politieke concepttoken FIGHT op de Ethereum-keten steeg met 150% nadat het op Gate was genoteerd, met een huidige marktwaarde van $ 66 miljoen. De achtergrond is toen de Amerikaanse presidentskandidaat Trump riep: “Vecht! Vechten! Vecht!” aan het publiek nadat ze tijdens een toespraak waren vermoord. Als gevolg hiervan werd het FIGHT-token geboren.</p>
<p><strong>Meme Sector:</strong><br>PONKE bereikte ooit $0,65, wat een nieuw historisch hoogtepunt is, met een huidige circulerende marktwaarde van ongeveer $300 miljoen.</p>
<p>MANEKI is binnen een dag met meer dan 20% gestegen. De officiële Telegram-community heeft aangekondigd dat het deze week zijn lang gepromote product zal uitbrengen, en de community verwacht dat dit nieuws de koopvraag van Maneki sterk zal stimuleren.</p>
<p>Andere meme-munten zoals NUB en PEOPLE hebben ook aanzienlijke stijgingen gezien.</p>
<p><strong>Faillissementssector:</strong><br>USTC, FTT, LUNC en anderen zijn gestegen. Luna Foundation heeft een schikking aangekondigd met de Amerikaanse overheid en FTX-compensatie is de volgende fase van het proces ingegaan. Marktfondsen speculeren voor een korte periode op populaire tokens uit de vorige bullmarkt, maar de hype wordt niet verwacht lang aan te houden.</p>
<h3 id="h3-Analyse20en20Samenvatting180581"><a name="Analyse en Samenvatting" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Analyse en Samenvatting</h3><p>De markt heeft de laatste tijd een sterke prestatie laten zien, met BTC en ETH die beide belangrijke prijsniveaus doorbreken en Altcoins in het algemeen stijgen, vooral de Meme-sector presteert opvallend goed. Op macro-economisch niveau heeft de verwachting van een mogelijke renteverlaging door de Federal Reserve een zekere stimulerende werking op het marktsentiment. Op korte termijn is het marktsentiment verschoven van angst naar hebzucht, en er is behoefte om  te zijn op mogelijke risico’s van een terugval.</p>
<h2 id="h2-Macro20Dow20Jones20Industrial20Average20bereikt20historisch20hoogtepunt20met20sterke20prestaties20in20small20cap20aandelen20Rente20verlagingen20naderen20goudprijzen20bereiken20nieuwe20hoogtes215363"><a name="Macro: Dow Jones Industrial Average bereikt historisch hoogtepunt, met sterke prestaties in small cap aandelen; Rente verlagingen naderen, goudprijzen bereiken nieuwe hoogtes" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Dow Jones Industrial Average bereikt historisch hoogtepunt, met sterke prestaties in small cap aandelen; Rente verlagingen naderen, goudprijzen bereiken nieuwe hoogtes</h2><p>Op dinsdag 16 juli steeg de aandelenmarkt van Erjie, waarbij de Dow Jones Industrial Average een historisch hoogtepunt bereikte. De sterker dan verwachte detailhandelsverkopen in de Verenigde Staten ondersteunen het standpunt van mensen dat de Federal Reserve een losse cyclus nadert om inflatie te beteugelen en een economische recessie te vermijden.</p>
<p>De drie belangrijkste aandelenindices in de Verenigde Staten zijn allemaal op dezelfde dag gestegen, maar grote groeiaandelen presteerden zwak, met NVIDIA en Microsoft aan kop van de stijgingen. Aan de andere kant blijven economisch gevoelige small cap-aandelen stijgen. De Russell 2000 is voor de vijfde opeenvolgende handelsdag meer dan 1% gestegen, wat de langste opeenvolgende opwaartse trend markeert sinds april 2000 en het hoogste niveau heeft bereikt sinds januari 2022.</p>
<p><strong>Belangrijkste Index Prestaties:</strong><br>-De Dow Jones Industrial Average: omhoog 1.85%, bereikt een historisch hoogtepunt</p>
<p>-S&amp;P 500-index: omhoog 0.64%</p>
<p>-NASDAQ Composite Index: up 0.20%</p>
<p>De economische gegevens die dinsdag zijn vrijgegeven, waaronder de detailhandelsverkopen die zijn vrijgegeven door het Amerikaanse ministerie van Handel, toonden sterkere resultaten dan verwacht. Dit heeft mensen ervan overtuigd dat ondanks de invoering van een contractief monetair beleid, de consumentenbestedingen, die ongeveer 70% van de Amerikaanse economie uitmaken, sterk blijven, waardoor zorgen worden weggenomen dat hoge rentetarieven kunnen leiden tot een economische recessie.</p>
<p>Op woensdag 17 juli opende de Aziatische markt met gemengde ups en downs. Vanwege de marktverwachtingen dat de wereldwijde rentetarieven zullen dalen, bereikten de goudprijzen op woensdag een historisch hoogtepunt en stegen de obligatieprijzen. De aandelenkoers van chipfabrikant TSMC daalde met 2%, waarbij de marktwaarde bijna $16 miljard verdampte.</p>
<p>De MSCI Asia Pacific aandelenindex bleef vlak, terwijl de Nikkei-index in Japan met 0,1% steeg. De Chinese aandelenmarkt presteerde slecht voor de tweede opeenvolgende dag.</p>
<p>Wat betreft de valutamarkt blijft de wisselkoers van de RMB ten opzichte van de Amerikaanse dollar stabiel op 7,2676. De wisselkoers van de Japanse yen ten opzichte van de Amerikaanse dollar is licht verzwakt tot 158,51. Ondanks vermoedelijke aankopen van yen door Japanse autoriteiten vorige week, ligt de wisselkoers van de Japanse yen ten opzichte van de Amerikaanse dollar nog steeds ver onder het 38-jarig dieptepunt van 161,96 dat begin juli werd bereikt. De wisselkoers van de euro ten opzichte van de dollar blijft stabiel op $1,0925.</p>
<p>De Britse inflatiegegevens worden later vandaag vrijgegeven, met de nadruk op inflatie in de dienstensector. Verwacht wordt dat het inflatiepercentage in de dienstensector in juni nog steeds 5,6% zal bedragen in vergelijking met dezelfde periode vorig jaar, wat op een hoog niveau blijft.</p>
<p>Wat betreft grondstoffen zijn de olieprijzen licht gedaald als gevolg van tekenen van verzwakte vraag uit China. Specifiek gemanifesteerd als:</p>
<p>-Brent ruwe olie futures: 13 cent omlaag naar $83.60 per vat</p>
<ul>
<li>Amerikaanse ruwe olie futures: daalden ook met 13 cent naar $80.63 per vat</li></ul>
<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 beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan ​​mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>