RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBvc2NpbGxlZXJ0IGVuIHZhbHQsIHByb2R1Y3RpZSBTVFggemFsIHdvcmRlbiBnZWhhbHZlZXJk

2024-09-02, 04:27

<p><img src="https://gimg2.gateimg.com/image/article/17252510949.2.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20inkomsten20van20Bitcoin20miners20in20augustus20bereikten20een20nieuw20dieptepunt20voor20het20jaar20STX20zal20een20halvering20zien521701"><a name="Crypto Dagelijkse Samenvatting: De inkomsten van Bitcoin miners in augustus bereikten een nieuw dieptepunt voor het jaar, STX zal een halvering zien" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De inkomsten van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> miners in augustus bereikten een nieuw dieptepunt voor het jaar, STX zal een halvering zien</h2><p>Volgens gegevens van Farside Investor, de Amerikaanse spotmarkt <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">bitcoin](/price/</a><a  rel="nofollow noopener noreferrer"  href=")-btc&quot;" target="_blank" class="blog _binnen_ [link</a> Bitcoin ETF had a netto-uitstroom van $175 miljoen afgelopen vrijdag, waarmee het de vierde opeenvolgende dag van netto-uitstroom vorige week markeerde. Daarvan had BlackRock IBIT geen instroom of uitstroom van fondsen, en de belangrijkste uitstroom van fondsen komt van ARKB en GBTC.</p>
<p>Afgelopen vrijdag was er geen instroom of uitstroom van fondsen in de Amerikaanse spotmarkt. <a  rel="nofollow noopener noreferrer"  href=" price="" &lt;a="" nofollow="" noopener="" noreferrer"="">ethereum</a>-eth” target=“_blank” class=“blog_inner_link”&gt;Ethereum ETF’s en het algemene handelsvolume van de ETH ETF’s was traag.</p>
<p><strong><a href="/price/<a href=" rel="nofollow noopener noreferrer" target="_blank">stacks</a>-stx” target=“_blank” class=“blog_inner_link”&gt;Stacks wordt verwacht succesvol te upgraden op 15 september, en de productie van STX zal worden gehalveerd.</strong></p>
<p>Volgens officiële bronnen zal na de succesvolle upgrade van <a href="/price/stacks-stx" target="_blank" class="blog_inner_link">Stacks</a> Nakamoto deze maand de beloning worden gehalveerd volgens nieuwe consensusregels, waarbij slechts 500 STX-tokens per Bitcoin-blok worden toegekend. Volgens het plan verwacht de officiële instantie een harde vork uit te voeren op een hoogte van 861.500 in het Stacks-blok, waarbij alle nieuwe Stacks Nakamoto-regels worden geactiveerd en tegelijkertijd een halvering van de productie wordt bereikt terwijl de efficiëntie van het Stacks-netwerk wordt verbeterd. Op basis van de huidige blokhoogte wordt verwacht dat de upgrade rond 15 september succesvol zal worden voltooid.</p>
<p>Er wordt gemeld dat de huidige Stacks blockchain het POX-miningmechanisme gebruikt, waarbij miners Bitcoin inzetten en STX-tokens als beloning krijgen. Elk Bitcoin-blok beloont 1.000 STX-tokens.</p>
<p><strong>De verdiensten van Bitcoin miners in augustus bereikten een nieuw dieptepunt voor het jaar</strong></p>
<p>Volgens gegevens van TheBlock hebben de winsten van Bitcoin-miners in augustus een nieuw laagtepunt bereikt voor het jaar, met in totaal $851,36 miljoen aan subsidies en vergoedingen, waarvan $20,76 miljoen afkomstig was van on-chain vergoedingen.</p>
<p>De mijnbouwopbrengst in augustus daalde met $99,75 miljoen in vergelijking met juli, en de on-chain handelskosten die door gebruikers werden bijgedragen, daalden met $4,14 miljoen in vergelijking met de vorige maand. Tussen blockhoogtes van 855.014 en 859.303 hebben Bitcoin-mijnwerkers in totaal 4.289 blokken gedolven, Foundry USA heeft 1.248 blokken gedolven, wat neerkomt op 29,10%, en Antpool heeft 1.074 blokken gedolven, wat neerkomt op 25,04%.</p>
<p><strong>Sui medeoprichter: Het maandelijkse ontgrendelingsvolume van SUI is ongeveer 2,6% van de omloopvoorraad en neemt nog steeds af</strong></p>
<p>Sui medeoprichter en CEO evan.sui reageerde op discussies op sociale media over ‘SUI’s jaarlijkse inflatie van meer dan 250% ‘door te zeggen:’ We verwelkomen kritiek. Dit is de enige manier waarop we beter kunnen worden. De maandelijkse ontgrendelingsvolume van SUI vertegenwoordigt ongeveer 2,6% van de circulerende voorraad en neemt nog steeds af.</p>
<p>Bovendien verklaarde Even ook dat SUI een van de weinige aanbod vaste POS-ketens is, in plaats van een inflatiepercentage van 5% -8% zoals de meeste andere ketens.</p>
<h2 id="h2-Markttrends20De20algehele20markt20fluctueert20en20daalt20en20IMX20zal20te20maken20krijgen20met20grote20ontgrendelingsmogelijkheden404435"><a name="Markttrends: De algehele markt fluctueert en daalt, en IMX zal te maken krijgen met grote ontgrendelingsmogelijkheden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: De algehele markt fluctueert en daalt, en IMX zal te maken krijgen met grote ontgrendelingsmogelijkheden</h2><h3 id="h3-Mainstream20Munten869684"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC is fluctuerend en gedaald, momenteel rond de $57.000. De BTC ETF heeft opnieuw een aanzienlijke uitstroom van $175 miljoen gehad op de laatste handelsdag;</p>
<p>ETH presteerde ook zwak en daalde vanochtend onder de $2.400. De ETH ETF’s hadden geen instroom of uitstroom van geld op de vorige handelsdag, en het handelsvolume van de ETH ETF’s lag ver onder de verwachtingen;</p>
<p>Altcoins zijn wijdverspreid beschikbaar en de markt is stil zonder duidelijke hotspots;</p>
<p>Wat betreft gegevensindicatoren staat de AHR999-index van vandaag op 0,6, wat één stap dichter bij de bodemvisindicator is; De Fear &amp; Greed Index is 26, wat duidt op een aanhoudende staat van angst in het marktsentiment.</p>
<h3 id="h3-Markt20Hotspots937097"><a name="Markt Hotspots:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots:</h3><p>Deze week zullen IMX en TAIKO een grote ontsluiting hebben: Taiko zal 12 miljoen TAIKO’s ontgrendelen om 20:00 uur op 5 september, ter waarde van ongeveer $ 19,32 miljoen, wat overeenkomt met 19,02% van de circulerende voorraad; Immutable zal 32,47 miljoen IMX-tokens ontgrendelen ter waarde van ongeveer $ 44,17 miljoen om 8:00 uur (Peking-tijd) op 6 september, wat overeenkomt met 2,06% van de circulerende voorraad;</p>
<p>FRONT-tokenmigratie: Frontier-token FRONT zal worden gemigreerd naar Self Chain-token SLF in een verhouding van 1:1, maar het totale aantal SLF-tokens zal aanzienlijk worden verhoogd. Het totale aantal FRONT-tokens is slechts 90 miljoen, terwijl het totale aantal SLF-tokens 360 miljoen is. In feite is dit een verwatering voor FRONT-tokenhouders, wat ook grote vraagtekens oproept in de gemeenschap.</p>
<h2 id="h2-Macroeconomie20Amerikaanse20aandelen20sloten20vorige20vrijdag20gezamenlijk20hoger20en20deze20week20zal20de20Fed20de20werkgelegenheidsgegevens20buiten20de20landbouw20voor20augustus20vrijgeven387805"><a name="Macroeconomie: Amerikaanse aandelen sloten vorige vrijdag gezamenlijk hoger, en deze week zal de Fed de werkgelegenheidsgegevens buiten de landbouw voor augustus vrijgeven" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: Amerikaanse aandelen sloten vorige vrijdag gezamenlijk hoger, en deze week zal de Fed de werkgelegenheidsgegevens buiten de landbouw voor augustus vrijgeven</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten gezamenlijk hoger, waarbij de S&amp;P 500-index steeg met 1,01% tot 5648,40 punten; de Dow Jones Industrial Average steeg met 0,55% tot 41563,08 punten; de Nasdaq-index steeg met 1,13% tot 17713,62 punten. Vorige week steeg de Dow Jones-index met 0,94% in een week, daalde de Nasdaq-index met 0,92% in een week en steeg de S&amp;P 500-index met 0,24% in een week.</p>
<p>Bovendien bedraagt het referentiepunt voor de 10-jarige schatkistrente 3,91% en is de op de Fed-rente gevoelige 2-jarige schatkistrente 3,91%.</p>
<p>Onder de populaire Amerikaanse aandelen daalde Apple met 0,34%, steeg Microsoft met 0,97%, steeg Nvidia met 1,51%, steeg Google C met 1,05%, steeg Google A met 0,99%, steeg Amazon met 3,71%, steeg Meta met 0,60%, steeg TSMC met 1,51%, steeg Tesla met 3,80%, en steeg AMD met 2,11%.</p>
<p>Vooruitkijkend naar de volgende week zal de Verenigde Staten zware gegevens vrijgeven, zoals seizoensgecorrigeerde niet-agrarische loonlijst, werkloosheidscijfer en gemiddeld uurloon voor augustus. De Federal Reserve zal haar rentevergadering houden op 17-18 september, en tenzij er belangrijke onverwachte gebeurtenissen zijn, is er geen twijfel dat de Fed haar renteverlagingcyclus in september zal beginnen. Het probleem ligt in de omvang van de renteverlagingen. Volgens de prijsstelling op de valutamarkt geloven beleggers momenteel dat de waarschijnlijkheid dat de Federal Reserve de rentetarieven in september met 25 basispunten verlaagt, ongeveer 70% bedraagt.</p>
<h3 id="h3-Conclusie44402"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h3><p>Over het algemeen bevindt de markt zich nog steeds in een periode van volatiliteit en aanpassing op korte termijn, met grote cryptocurrencies zoals BTC en ETH die een zwakke prestatie vertonen en het sentiment op de Altcoin-markt traag is. Investeerders moeten nauwlettend de veranderingen in belangrijke steun- en weerstandsniveaus volgen, evenals de impact van de aankomende grootschalige ontgrendelingsgebeurtenissen van IMX en TAIKO op de markt.</p>
<p>Onder de voortdurende staat van angst in de marktsentiment en de invloed van meerdere negatieve factoren, wordt het aanbevolen dat investeerders voorzichtig blijven en grote transacties vermijden in een zeer onzekere marktomgeving. Ondertussen, let op mogelijke koopjeskansen, maar wacht op duidelijkere marktsignalen voordat u beslissingen neemt.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Ijs</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 investeringssuggesties.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het opnieuw plaatsen van het artikel is toegestaan 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>