RGFnZWxpamtzIE5pZXV3cyB8IEJUQyBrZWVydCB0ZXJ1ZyBuYWFyIG5lZXJ3YWFydHNlIHRyZW5kLCBtYXJrdCB3YWNodCBvcCBDUEktZ2VnZXZlbnMgdmFuIHdvZW5zZGFn

2024-08-12, 04:25

<p><img src="https://gimg2.gateimg.com/image/article/172343654812.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20spot20ETF20heeft20vorige20week20aanzienlijke20uitstroom20ervaren20en20WBTC20kampt20met20een20vertrouwenscrisis20in20de20gemeenschap719397"><a name="Crypto Dagelijkse Samenvatting: BTC spot ETF heeft vorige week aanzienlijke uitstroom ervaren en WBTC kampt met een vertrouwenscrisis in de gemeenschap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC spot ETF heeft vorige week aanzienlijke uitstroom ervaren en WBTC kampt met een vertrouwenscrisis in de gemeenschap</h2><p>Volgens de gegevens van Farside Investor bedroeg de algehele nettostroom van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De uitstroom van spot ETF’s bedroeg afgelopen vrijdag bijna $90 miljoen. Onder hen had Grayscale GBTC een uitstroom van $77 miljoen, terwijl BlackRock IBIT een kleine instroom van $9,6 miljoen had. Vorige week was er een significante uitstroom van fondsen in het algemeen.</p>
<p>Afgelopen vrijdag was er een algemene nettoutstroom van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> De ETF’s bedroegen bijna $16 miljoen en de uitstroom is aanzienlijk afgenomen. Vorige week had de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ETF een cumulatieve nettostroom van $104,8 miljoen en het algemene handelsvolume bleef relatief klein.</p>
<p><strong>MakerDAO is van plan de omvang van het WBTC-onderpand te verkleinen om mogelijke risico’s in verband met veranderingen in bewaurrechten aan te pakken</strong></p>
<p>Volgens on-chain gegevensmonitoring ondersteunt WBTC momenteel Ethereum/Base/Kave/. <a href="/price/osmosis-osmo" rel="nofollow noopener noreferrer" target="_blank">Osmose</a>/ <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">Tron</a> netwerken, waarbij Ethereum mainnet-munten goed zijn voor 99,8%. Op dit moment zijn er 154.726 WBTC’s (ter waarde van $9,45 miljard) gemunt, wat overeenkomt met 0,78% van de totale marktkapitalisatie van Bitcoin. Volgens gegevens van Dune-panelen worden meer dan 41% van de WBTC’s momenteel gebruikt in het uitleen-ecosysteem, waarbij MakerDAO het grootste gebruiksscenario is (acceptanten), en bijna 32% wordt gebruikt voor directe transacties. MakerDAO heeft plannen om een voorstel te lanceren om de omvang van WBTC-onderpand te verminderen in een stemming die gepland staat voor 12 augustus.</p>
<p><strong>Federal Reserve Governor Bauman: De afkoeling van de arbeidsmarkt wordt overdreven, en wees voorzichtig met renteverlagingen</strong></p>
<p>Federal Reserve Governor Bauman verklaarde dat de inflatie ‘ongemakkelijk’ boven het streefniveau blijft. Er is een opwaarts risico op inflatie en de arbeidsmarkt blijft versterken, wat aangeeft dat ze mogelijk niet bereid is om renteverlagingen te ondersteunen tijdens de volgende vergadering van Amerikaanse centrale bankfunctionarissen in september. Ze zei dat de vooruitgang die is geboekt bij het verminderen van de inflatie in mei en juni welkom is, maar dat de inflatie boven het streefniveau van 2% van het comité blijft, wat verontrustend is. Bij het overwegen van aanpassing van het huidige beleidsstandpunt zal ik voorzichtig blijven. Ze verklaarde ook dat het Amerikaanse begrotingsbeleid, immigratiedruk op de vastgoedmarkt en geopolitieke risico’s allemaal opwaartse druk op de huizenprijzen kunnen uitoefenen, en dat de recente stijging van de werkloosheid tot 4,3% de mate van afkoeling van de arbeidsmarkt kan overdrijven.</p>
<p><strong>Standpunt: Crypto-venturekapitaal vertraagt zijn investeringssnelheid, het vasthouden van BTC/ETH kan aanzienlijke rendementen opleveren en het gebrek aan nieuwe verhalen is de belangrijkste reden</strong></p>
<p>Partner Adam Cochran van Cinneamhain Ventures plaatste op sociale media dat er een subtiele reden is waarom durfkapitaalfondsen hun investeringen in cryptocurrencies aanzienlijk hebben vertraagd. De meeste durfkapitaalfondsen hebben beperkte partners (LP’s), die voornamelijk geïnteresseerd zijn in rendementen boven indexfondsen. Maar op middellange termijn kunnen het eenvoudigweg aanhouden van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en Ethereum indexfondsen gemakkelijk overtreffen qua risico-rendementsverhouding.</p>
<p>Dit stelt durfkapitalisten in staat om een afwachtende houding aan te nemen ten opzichte van Bitcoin en Ethereum, wachtend op veiligere en meer winstgevende kansen, in plaats van in een vroeg stadium evenveel risico te nemen bij startups als in andere industrieën. Omdat er geen activa in andere markten zijn die holdingrendementen opleveren zoals BTC of ETH. Adam Cochran verklaarde dat durfkapitaalbedrijven tijdens de vorige cryptocyclus (2020-2024) “zeer actief leken” en hoopten een fortuin te verdienen met deelnemers door te investeren in “reeds explosieve” toepassingen. Maar momenteel zijn verschillende bekende verhalen (NFT’s, AMM Fork, DeFi, L2s) tot een einde gekomen en is het nog onduidelijk wat de volgende stappen moeten zijn.</p>
<h2 id="h2-Markttrends475511"><a name="Markttrends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends</h2><h3 id="h3-Mainstream20Munten679416"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC: Na vorige week een aanzienlijke opleving te hebben doorgemaakt, is Bitcoin (BTC) teruggekeerd naar zijn neerwaartse trend. Vanmorgen zakte BTC op een gegeven moment onder de $ 58.500 en het marktsentiment is momenteel traag. Het is vermeldenswaard dat de netto-uitstroom van BTC-spot-ETF’s in augustus relatief groot was, wat een belangrijke factor kan zijn geweest die tot een prijscorrectie heeft geleid.</p>
<p>ETH: Ethereum is sinds het herstellen naar $2.700 gedaald en zweeft momenteel rond $2.550, waarmee het terugkeert naar het prijsniveau van het begin van dit jaar. De daling van ETH weerspiegelt ook het gebrek aan sterke opwaartse momentum op de algehele markt.</p>
<p>Altcoins: Altcoins zijn over het algemeen gedaald en er zijn geen duidelijke hot sectors. Het algemene marktsentiment is relatief laag en investeerders ontbreken vertrouwen.</p>
<h3 id="h3-Gegevensindicatoren201203"><a name="Gegevensindicatoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gegevensindicatoren</h3><p>AHR999-index: de AHR999-index van vandaag is 0,66, wat aangeeft dat de huidige prijs nog steeds een goed punt is om in batches te kopen.</p>
<p>Fear &amp; Greed Index: De huidige Fear &amp; Greed Index is 25, wat aangeeft dat de marktsentiment nog steeds in een relatief lage staat is.</p>
<h3 id="h3-Markt20Hotspots884885"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p><a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Ecosysteem: SOL herstelde zich van een dieptepunt van $110 tot boven de $160 vorige week, maar daalde vervolgens scherp op zondag, waarbij het op een gegeven moment naar $141 daalde. De tokens van het Solana-ecosysteem presteren niet langer sterk, aangezien eerder sterke herstellende tokens zoals POPCAT en WIF scherp zijn gedaald vanaf hun hoogtepunten. Er wordt gefluisterd dat Jump Crypto een belangrijke investeerder is achter SOL, en als Jump Crypto zich terugtrekt uit het cryptoveld, kan dit meer impact hebben op SOL.</p>
<p>BTC-ecosysteem: De grootste ingepakte Bitcoin (WBTC) op de Ethereum-keten ontving een belangrijke gebeurtenisupdate tijdens het weekend, naar verluidt overgenomen door een bedrijf dat wordt gecontroleerd door Justin Sun, wat gemeenschapsdistrust veroorzaakte. Ondertussen heeft de token T van Threshold Network, dat volledig gedecentraliseerde Threshold Bitcoin (tBTC) heeft uitgegeven, een aanzienlijke stijging gezien, en de huidige prijs is gedaald. Het is vermeldenswaard dat de historische circulatie van WBTC meer dan 150.000 overschrijdt.</p>
<p>De openbare keten Sui: SUI herstelde zich meer dan 100% vanaf het dieptepunt van vorige week en werd de best presterende openbare ketentoken van vorige week. Op het nieuwsfront profiteert de stijging van SUI van de lancering van SUI Trust door Grayscale. Bovendien zal SUI op 1 september een token-ontgrendeling van $60 miljoen ontvangen, wat mogelijk verdere invloed kan hebben op de prijs.</p>
<h2 id="h2-Macroeconomie20Risicoactivamarkten20zoals20de20Amerikaanse20aandelenmarkt20wachten20op20de20CPIgegevens20van20woensdag520336"><a name="Macroeconomie: Risico-activamarkten zoals de Amerikaanse aandelenmarkt wachten op de CPI-gegevens van woensdag." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: Risico-activamarkten zoals de Amerikaanse aandelenmarkt wachten op de CPI-gegevens van woensdag.</h2><p>Afgelopen vrijdag sloten de drie belangrijkste Amerikaanse aandelenindices gezamenlijk hoger. De S&amp;P 500-index steeg met 0,47% naar 5.344,16 punten; de Dow Jones Industrial Average steeg met 0,13% naar 39.497,54 punten; de Nasdaq-index steeg met 0,51% naar 16.745,30 punten. Het referentiepunt voor de 10-jarige Treasury-rente is 3,94%, terwijl de 2-jarige Treasury-rente, die het meest gevoelig is voor het rentebeleid van de Federal Reserve, 4,05% bedraagt.</p>
<p>Onder de populaire Amerikaanse aandelen steeg Apple met 1,37%, steeg Microsoft met 0,83%, daalde Nvidia met 0,21%, steeg Google C met 0,95%, steeg Google A met 1,01%, steeg Amazon met 0,69%, steeg Meta met 1,60%, steeg TSMC met 1,56%, steeg Tesla met 0,58%, en daalde AMD met 1,50%.</p>
<p>De intense marktvolatiliteit van vorige week heeft ervoor gezorgd dat de Chicago Board Options Exchange Volatility Index (VIX), die de volatiliteit van de S&amp;P 500-index (SPX) meet, zijn hoogste niveau heeft bereikt sinds de piek van de pandemie in 2020. Volgens gegevens van Citigroup, gebaseerd op Put-Call Parity, verwachten handelaren dat de S&amp;P 500-index met 1,2% in beide richtingen zal fluctueren wanneer CPI-gegevens op woensdag worden vrijgegeven.</p>
<h3 id="h3-Conclusie423213"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Over het algemeen zijn BTC en ETH teruggekeerd naar een neerwaartse trend en is het algemene marktsentiment relatief traag. Hoewel de AHR999-index en de Fear Greed-index aangeven dat de huidige markt een goed koopargument is, moeten beleggers nog steeds voorzichtig te werk gaan en aandacht besteden aan verdere markttrends.</p>
<p>De turbulentie van Solana- en BTC-ecoen, evenals de sterke prestaties van de openbare keten Sui, geven de verschuiving en volatiliteit van markthotspots aan. In de nabije toekomst kan de markt blijven worden beïnvloed door macro-economische factoren en beleidswijzigingen. Voordat de Amerikaanse CPI-gegevens op woensdag worden vrijgegeven, wordt gebruikers aangeraden een afwachtende houding aan te nemen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>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 zal worden toegestaan mits naar Gate.io wordt verwezen. In alle glen zullen juridische stappen worden ondernomen vanwege auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>