RGFnZWxpamtzIG5pZXV3cyB8IENyeXB0by1tYXJrdCBzdGFhdCB2b29yIG5pZXV3ZSB2ZXJrb29wem9yZ2VuLCBCVEMgc2xhYWdkZSBlciBuaWV0IGluIG9tICQ3MC4wMDAgdmFzdCB0ZSBob3VkZW47IEFWQVgsIFcgZW4gYW5kZXJlIGF1Z3VzdHVzLXRva2VucyBvbnRncmVuZGVsZW4gYmlqbmEgJDEgbWlsamFyZA==

2024-07-30, 04:13

<p><img src="https://gimg2.gateimg.com/image/article/17223124431_23.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20markt20wordt20geconfronteerd20met20nieuwe20verkoopzorgen20en20BTC20is20er20niet20in20geslaagd20om207000020vast20te20houden20AVAX20W20en20andere20augustus20tokens20zullen20bijna20120miljard20ontgrendelen2021Shares20CETH20Integrated20Chainlink20Reserve20Proof800203"><a name="Crypto Dagelijkse Samenvatting: De markt wordt geconfronteerd met nieuwe verkoopzorgen, en BTC is er niet in geslaagd om $70.000 vast te houden; AVAX, W en andere augustus tokens zullen bijna $1 miljard ontgrendelen; 21Shares’ CETH Integrated Chainlink Reserve Proof" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De markt wordt geconfronteerd met nieuwe verkoopzorgen, en BTC is er niet in geslaagd om $70.000 vast te houden; AVAX, W en andere augustus tokens zullen bijna $1 miljard ontgrendelen; 21Shares’ <a href="/price/ceth-ceth" target="_blank" class="blog_inner_link">CETH</a> Integrated Chainlink Reserve Proof</h2><p>Laten we eerst de handelsactiviteit van nader bekijken <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF’s. Volgens gegevens van Farside Investor had de Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (GBTC) op 23 juli een kapitaaluitstroom van $54,3 miljoen. Ondertussen had de Fidelity Bitcoin Spot ETF (FBTC) een uitstroom van $5,9 miljoen, terwijl de Bitwise Bitcoin Spot ETF (BITB) een uitstroom van $21,3 miljoen had.</p>
<p>De netto instroom van Bitwise <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Spot ETF (ETHW) op de eerste dag werd tijdelijk gerapporteerd op $204 miljoen; Fidelity Ethereum Spot ETF (FETH) had een netto instroom van $24,8 miljoen op de eerste dag; Grayscale Ethereum Spot ETF (ETHE) had een netto instroom van $71,3 miljoen op de eerste dag.</p>
<p><strong>Markt wordt geconfronteerd met nieuwe verkoopzorgen, BTC slaagt er niet in $70,000 vast te houden</strong></p>
<p>Bitcoin (BTC) steeg in de vroege Europese handel bijna tot $70.000 en bereikte daarmee het hoogste niveau sinds begin juni. Deze opwaartse trend werd gedreven door de positieve marktreactie op de aanwezigheid van Donald Trump bij BTC 2024 in Nashville. De Republikeinse presidentskandidaat onthulde dat als hij in november wordt gekozen, hij een strategische Bitcoin-reserve zal oprichten. Bitcoin slaagde er echter niet in om zijn hoogtepunt van $70.000 vast te houden.</p>
<p>Op 29 juli, na opening van Wall Street, kreeg Bitcoin enorme verkoopdruk. Volgens Arkham Intelligence heeft een portemonnee die als eigendom van de Amerikaanse overheid is gelabeld, op maandag $2 miljard aan Bitcoin overgemaakt naar een niet-geïdentificeerde portemonnee.</p>
<p>Ongeveer 28.000 Bitcoins, met een totale waarde van meer dan $2 miljard, lijken verband te houden met fondsen die eerder door het Amerikaanse ministerie van Justitie in beslag zijn genomen van de dark web markt (aan het einde van vorig jaar heeft een Amerikaans hof van beroep uiteindelijk besloten om 69.370 Bitcoins en andere cryptocurrencies die verband houden met het netwerk in beslag te nemen). Arkham Intelligence wees erop dat ongeveer een uur na voltooiing van de overdracht de Amerikaanse overheid Bitcoin in twee afzonderlijke adressen heeft opgesplitst, waarbij 19.800 Bitcoins (ongeveer $1,3 miljard) aan het ene adres en 10.000 Bitcoins (ongeveer $670 miljoen) aan een ander adres zijn toegewezen.</p>
<p>Dit nieuws kan ook van invloed zijn geweest op de veranderingen in de BTC-prijzen. Op dit moment is de prijs van Bitcoin $66,234.78, een daling van 4.8% binnen 24 uur.</p>
<p><strong>21Shares’ <a href="/price/ceth-ceth" rel="nofollow noopener noreferrer" target="_blank">CETH (CETH)</a> Integratie Chainlink Reserve Proof om transparantie te verbeteren</strong></p>
<p>21Shares US LLC, een dochteronderneming van 21Shares AG, heeft standaard Chainlink-reservebewijzen geïntegreerd op Ethereum, met als doel de transparantie te vergroten van de Ethereum-reserves die de 21Shares Core Ethereum ETF (aandelencode CETH) ondersteunen.</p>
<p>Volgens het persbericht heeft 21Shares Chainlink gekozen als zijn voorkeurs gedecentraliseerd computerplatform vanwege de succesvolle ervaring van Chainlink in het bereiken van een totale waarde van meer dan $12 biljoen op de on-chain markt.</p>
<p>De persverklaring vermeldt: “Door het integreren van Chainlink’s reservebewijsoplossing kan 21Shares een duidelijk inzicht krijgen in de onderliggende ETH-reserves van CETH, waardoor investeerders meer zekerheid en vertrouwen krijgen dat CETH wordt ondersteund door onderliggende ETH-bezittingen.”</p>
<p>In februari van dit jaar kondigde 21Shares de integratie aan van Chainlink Reserve Proof om de transparantie van de Bitcoin-reserves die de ARK 21Shares Bitcoin ETF ondersteunen te verbeteren. ARKB werd gelanceerd in januari en beheert momenteel $3,2 miljard aan activa.</p>
<p>Johann Eid, Chief Business Officer van Chainlink Labs, zei: “We zijn verheugd om verder samen te werken met 21Shares en een belangrijke mijlpaal in onze sectorgeschiedenis te ondersteunen door meer transparantie te bieden aan de 21Shares Core Ethereum ETF via Chainlink Reserve Proof. 21Shares speelt een cruciale rol bij het ondersteunen van de adoptie van digitale activa, en het Chainlink-platform helpt financiële instellingen om hun visie van naadloze tokenisatie op mondiale schaal te verwezenlijken.”</p>
<p>CETH is een van de negen Ethereum spot ETF’s die vorige week naar de beurs zijn gegaan. Acht van de nieuwe fondsen hebben een nettostroom van meer dan $1 miljard, maar de nettoutstroom van ETHE onder Grayscale is zo hoog als $1,5 miljard, wat ver boven CETH uitkomt.</p>
<p><strong>Het August Token-projectplan om te ontgrendelen: inclusief populaire tokens zoals AVAX en W, met een waarde van bijna $1 miljard.</strong></p>
<p>Na enkele maanden van luchtdroppen zal het cross-chain project van Wormhole deze maand een derde van zijn token-circulatie ontgrendelen: 600 miljoen tokens, momenteel ter waarde van ongeveer $180 miljoen. Het is echter verre van het enige project dat een groot aantal tokens ontgrendelt. ZetaChain zal bijna een vijfde van zijn circulerende aanbod ontgrendelen, en de ontgrendelingswaarde van tokens voor verschillende andere projecten zal ook $50 miljoen of meer bereiken.</p>
<p><strong>AVAX: 20 augustus, $268 miljoen</strong><br>Layer 1 blockchain <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Lawine</a> zal zijn omloop van 2,42% ontgrendelen: 9,5 miljoen tokens, momenteel ter waarde van $268 miljoen, op 20 augustus.</p>
<p><strong>Wormhole: 3 augustus, $180 miljoen</strong><br>Wormhole zal op 3 augustus 600 miljoen tokens ontgrendelen, wat gelijk staat aan een derde van zijn omloopvoorraad, met een waarde van meer dan $180 miljoen tegen de huidige prijzen. Wormhole is de communicatiebrug tussen <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> en andere top DeFi-projecten met eenhoornwaarderingen. Het project heeft onlangs airdrops voltooid van meer dan 670 miljoen tokens in april.</p>
<p><strong>Sui: 1 augustus, $50 miljoen </strong><br>Layer 1 Network SUI zal tokens ontgrendelen samen met zijn concurrent. <a href="/price/aptos-apt" rel="nofollow noopener noreferrer" target="_blank">Aptos</a> deze maand wordt 2,56% van zijn circulerende aanbod ontgrendeld op 1 augustus: 64 miljoen tokens, momenteel ter waarde van ongeveer $50 miljoen. Het netwerk gaat bijna 15 maanden live.</p>
<p><strong>Aptos: 12 augustus, $80 miljoen</strong><br>Aptos is een van de twee projecten die voornamelijk bestaan uit voormalige leden van het Facebook Libra-valutaproject (het andere project is Sui), die op 12 augustus een extra 2,41% van zijn omloopvoorraad, of 11,31 miljoen tokens, zal vrijgeven, met een huidige waarde van ongeveer $80 miljoen.</p>
<p><strong>ARB: 16 augustus, $67 miljoen</strong><br>Arbitrarum is onlangs het eerste Layer 2-netwerk geworden op <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> om een totale transactievolume van $150 miljard te bereiken, en zal op 16 augustus 2,8% van zijn omloop ontgrendelen. Deze 92,6 miljoen tokens zijn momenteel ongeveer $67 miljoen waard.</p>
<p><strong>OP: 31 juli, $55 miljoen</strong><br>Ethereum’s Layer 2-netwerk <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> Op 31 juli worden 31,3 miljoen tokens ontgrendeld voor kernbijdragers en investeerders, wat bijna 2,8% van de circulerende voorraad vertegenwoordigt. De huidige waarde van deze tokens is ongeveer $55 miljoen. <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> ondersteunt ook het Layer 3-netwerk op zijn superchain.</p>
<p><strong>ZetaChain: 1 augustus, $35 miljoen</strong><br>ZetaChain is een Layer 1-keten die eerder dit jaar is gelanceerd met als doel uiteindelijk veel verschillende blockchains te integreren in één platform, nadat het vorig jaar $27 miljoen heeft opgehaald. Op 1 augustus zal het 18,92% van zijn circulatie ontgrendelen. Op basis van de huidige prijzen zijn bijna 54 miljoen tokens ongeveer $35 miljoen waard.</p>
<h2 id="h2-Markttrends20De20algehele20markt20daalt20en20er20is20een20gebrek20aan20aanhoudende20hotspots20in20de20markt48143"><a name="Markttrends: De algehele markt daalt en er is een gebrek aan aanhoudende hotspots in de markt" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De algehele markt daalt en er is een gebrek aan aanhoudende hotspots in de markt</h2><p>BTC: BTC daalde scherp nadat het kortstondig $70.000 had bereikt en bevindt zich momenteel onder de $67.000, mogelijk als gevolg van de Amerikaanse overheid die $2 miljard aan BTC overdraagt.</p>
<p>ETH: ETH presteerde relatief goed, met een daling van ongeveer $150 miljoen in vergelijking met de voorgaande dagen, ondanks een uitstroom van $200 miljoen uit de Grayscale ETF.</p>
<p>Altcoins: Er zijn geen nieuwe hotspots op de markt, en over het algemeen dalen de Altcoins.</p>
<h3 id="h3-Gegevensindicatoren528952"><a name="Gegevensindicatoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevensindicatoren</h3><p>AHR999 Index: Vandaag staat de AHR999 Index op 0,89, wat wijst op een lichte daling en nog steeds geschikt is voor langetermijnbeleggers om regelmatig te investeren.</p>
<p>Angst &amp; hebzucht index: Momenteel staat deze op 67, de hebzuchtige sentiment in de markt is iets afgekoeld nu de algehele markt daalt.</p>
<h3 id="h3-Macro20Nieuws141372"><a name="Macro Nieuws" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro Nieuws</h3><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt hebben geschommeld, met een benchmark van 10-jaars Amerikaanse schatkistrendement van 4,17% en een 2-jaars schatkistrendement, dat het meest gevoelig is voor het beleidsrentetarief van de Federal Reserve, van 4,36%. De risicomarkt wacht op de rentebeslissing van de Federal Reserve om 2:00 uur op donderdag.</p>
<h3 id="h3-Markt20Hotspots435926"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Meme-sectie: NEIRO, NEIRO is de naam van een nieuwe huisdier aangenomen door Doge-eigenaren, die afgelopen weekend marktpopulariteit heeft verworven met een kortetermijnmarktwaarde van meer dan $100 miljoen. Het is echter sindsdien terugglen en het is moeilijk om een langetermijn-hotspot te worden. BOME en MOG zijn beide volledig verhandelbare tokens met een stijging van meer dan 10%. BOME heeft dit jaar de Meme-rage op de Solana-keten gestart, terwijl MOG Meme-enthousiastelingen op de Ethereum-keten heeft aangetrokken met zijn iconische gekleurde zonnebril.</p>
<p>AI-sector: AI-tokens zoals WLD, FET en IO hebben allemaal een daling ervaren. In de markt van dit jaar leidde de AI-sector ooit de markt samen met de Meme-sector, maar met de grootschalige ontgrendeling van de toonaangevende WLD heeft de AI-sector dringend nieuwe leiders nodig om op te komen.</p>
<h3 id="h3-Conclusie542072"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Het huidige marktsentiment is relatief optimistisch, maar iets afgekoeld. BTC is teruggekeerd naar onder de $67.000, terwijl ETH relatief goed heeft gepresteerd. Altcoins zijn over het algemeen dalende, en de markt ontbreekt nieuwe hotspots. Meme-tokens zoals NEIRO, BOME en MOG hebben een uitstekende prestatie laten zien, maar hun duurzaamheid moet nog worden waargenomen. De AI-sector staat onder druk om grote hoeveelheden tokens vrij te geven en heeft behoefte aan de opkomst van nieuwe toonaangevende tokens. Beleggers moeten nauwlettend de beleidsbewegingen van de Federal Reserve in de gaten houden en de impact van de aanstaande vrijgave van tokens op de markt.</p>
<h2 id="h2-Macro20Notulen20van20de20vergaderingen20van20de20Federal20Reserve20en20de20Bank20of20Japan20vrijgegeven20wat20leidt20tot20een20daling20van20de20Aziatische20aandelenmarkten20Beleggers20wachten20op20belangrijke20gegevens4893"><a name="Macro: Notulen van de vergaderingen van de Federal Reserve en de Bank of Japan vrijgegeven, wat leidt tot een daling van de Aziatische aandelenmarkten; Beleggers wachten op belangrijke gegevens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Notulen van de vergaderingen van de Federal Reserve en de Bank of Japan vrijgegeven, wat leidt tot een daling van de Aziatische aandelenmarkten; Beleggers wachten op belangrijke gegevens</h2><p><strong>Beleggers wachten op belangrijke prestatie-, werkgelegenheidsgegevens en de vergadering van de Federal Reserve, de S&amp;P 500 index stijgt lichtjes</strong></p>
<p>Op 29 juli steeg de S&amp;P 500-index lichtjes na volatiele handel, terwijl investeerders wachtten op de publicatie van prestatierapporten van grote technologiebedrijven deze week, de beslissing van de Federal Reserve om de rente te verlagen en de belangrijke Amerikaanse werkgelegenheidsgegevens.</p>
<p>De hoogtepunten van deze week zijn de vergadering van de Federal Reserve op woensdag en het werkgelegenheidsrapport op vrijdag. Daarnaast zijn er kwartaalverslagen van grote technologiebedrijven zoals Microsoft, Amazon en Apple, die beleggers aanwijzingen zullen geven om te bepalen of technologieaandelen te maken hebben met kwetsbaarheid of hun recente winsten kunnen voortzetten.</p>
<p>De prestaties van de aandelenindex zijn als volgt: de Dow Jones-index daalde met 0,12%, de S&amp;P-index steeg met 0,08% en de Nasdaq-index steeg met 0,07%.</p>
<p><strong>Notulen van de vergaderingen van de Federal Reserve en de Bank of Japan vrijgegeven, olieprijzen dalen, Aziatische aandelenmarkten kelderen</strong></p>
<p>Op maandag 30 juli werden obligatie-, valuta- en aandelenmarkten voorzichtig verhandeld in afwachting van de bijeenkomsten van de centrale banken van de VS en Japan en een reeks belangrijke kwartaalverslagen van bedrijven.</p>
<p>De markt verwacht over het algemeen dat de Verenigde Staten deze week de rente niet zullen verlagen, maar verwacht volledig een verlaging van 25 basispunten in de federale fondsenrente in september, dus er wordt verwacht dat beleidsmakers dovish-opmerkingen maken. In Japan verwacht de markt dat de mogelijkheid dat de Bank of Japan de rente met 10 basispunten verhoogt, dicht bij 60% ligt, en kijkt uit naar de aankondiging van de Bank of Japan over hoe het zijn grootschalige obligatieaankoopprogramma zal afsluiten.</p>
<p>De Nikkei-index in Japan daalde vorige week bijna 6% en daalde nog eens 0,7% bij de opening van de handel. De MSCI Asia Pacific aandelenindex daalde met 0,7%.</p>
<p>In de valutamarkt blijven de Amerikaanse dollar en de Japanse yen binnen een relatief nauwe marge, even op adem komen na de recente doorbraaktrend. De wisselkoers van de Japanse yen ten opzichte van de Amerikaanse dollar is aanzienlijk hersteld van het 38-jarig dieptepunt van 161,96 dat begin juli werd bereikt en zweeft momenteel rond de 153,95. De wisselkoers van de euro ten opzichte van de Amerikaanse dollar is 1,0851, terwijl de wisselkoers van de Australische dollar ten opzichte van de Amerikaanse dollar lichte druk ondervindt. Als gevolg van de daling van de grondstoffenprijzen is de wisselkoers van de Australische dollar ten opzichte van de Amerikaanse dollar gedaald van 0,68 drie weken geleden tot momenteel 0,6536.</p>
<p>In de grondstoffenmarkt zijn de olieprijzen op dinsdag gedaald naar het laagste niveau in zeven weken als gevolg van zwakke vraagvooruitzichten. Brent ruwe olie future daalde ‘s nachts naar $79,36 en veranderde in een verkopersmarkt.</p>
<p>Op dinsdag had de goudprijs moeite om momentum te vinden, omdat beleggers op zoek waren naar meer aanwijzingen over wanneer de Amerikaanse centrale bank deze week de rente zou verlagen tijdens beleidsvergaderingen en gegevenspublicaties. Spot goud daalde met 0,1% tot $2.380,31 per ounce, terwijl de prijzen van Amerikaanse goud futures bijna onveranderd bleven op $2.377,30 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 opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt genoemd. In alle glen zal er juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>