RGFnZWxpamtzIG5pZXV3cyB8IFNFQyBoZWVmdCBkZSBiZXNsaXNzaW5nIG92ZXIgZGUgYWFudnJhYWcgdm9vciBCVEMgU3BvdCBFVEYncyB1aXRnZXN0ZWxkOyBDWUJFUiBzdGVlZyBtZXQgMTU4JSBiaW5uZW4gNDggdXVyOyBIZXQgZGFnZWxpamtzZSBoYW5kZWxzdm9sdW1lIHZhbiBGcmllbmQudGVjaCBpcyBtZXQgbWVlciBkYW4gOTU

2023-09-01, 03:42

<p><img src="https://gimg2.gateimg.com/image/article/16935476730901.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20De20SEC20heeft20de20beslissing20over20de20aanvraag20voor20Bitcoin20spot20ETFs20uitgesteld20CYBER20is20in204820uur20tijd20met2015820gestegen898703"><a name="Crypto Daily Digest: De SEC heeft de beslissing over de aanvraag voor Bitcoin spot ETF’s uitgesteld; CYBER is in 48 uur tijd met 158% gestegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: De SEC heeft de beslissing over de aanvraag voor <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s uitgesteld; CYBER is in 48 uur tijd met 158% gestegen</h2><p>Een schermafbeelding van het document dat is vrijgegeven door Bloomberg-analist James Seyfart laat zien dat de SEC zijn beslissing over het heeft uitgesteld. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF-aanvragen van WisdomTree, Invesco Galaxy, Valkyrie, Fidelity, VanEck, Bitwise en BlackRock. Het document toont aan dat de nieuwe deadline voor SEC-beslissingen over de aanvragen van WisdomTree, Invesco Galaxy, Fidelity, VanEck en BlackRock 17 oktober is, Valkyrie 19 oktober en Bitwise 16 oktober.</p>
<p>De Web3-portemonnee van Robinhood ondersteunt al Bitcoin en <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> gebruikers van de zelfbewaarde Web3-portemonnee van Robinhood kunnen nu Bitcoin- en Dogecoin-netwerken gebruiken om cryptocurrency te hosten, te verzenden en te ontvangen. Voordat het woensdag ondersteuning voor Bitcoin- en Dogecoin-netwerken lanceerde, voegde het ook ondersteuning toe voor Arbitrum en <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>.</p>
<p>Bovendien maakt Robinhood ook in-app transacties mogelijk op de <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> netwerk. Vanaf woensdag kunnen geselecteerde gebruikers meer dan 200 tokens gebruiken. Het platform verklaarde dat het deze diensten de komende weken aan iedereen zal aanbieden. Eerder konden Robinhood Wallet-gebruikers alleen cryptocurrencies verhandelen op het <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> netwerk via de gedecentraliseerde handelsaggregator <a href="/price/0x-zrx" rel="nofollow noopener noreferrer" target="_blank">0x</a> API.</p>
<p>Het bedrijf verklaarde dat Robinhood-portefeuillegebruikers geen Ether (ETH) hoeven aan te houden om te kunnen wisselen, aangezien netwerkvergoedingen automatisch worden afgetrokken van de tokens die ze al in bezit hebben.</p>
<p>Recentelijk is de meest indrukwekkende token op de cryptomarkt Cyberconnect (CYBER) geweest, die in minder dan twee dagen is gestegen van ongeveer $3,6 naar meer dan 150%, met een piek van bijna $9,3.</p>
<p>De reden hiervoor wordt begrepen als gevolg van Zuid-Koreaanse investeerders die de recente prijsstijging van CYBER hebben aangedreven.</p>
<p>Sinds de lancering van CYBER op de Zuid-Koreaanse cryptocurrency-beurs Upbit op 22 augustus hebben Upbit-portefeuilleadressen ongeveer 3,6 miljoen CYBERs ter waarde van ongeveer $32,43 miljoen vastgehouden; Vanwege de aandacht van de Koreaanse munt-speculatiegemeenschap die zich verplaatst naar CYBER, is de grootste beurs, Upbit, nu Binance voorbijgestreefd als de grootste houder van CYBER, goed voor 33% van de token circulatiesupply.</p>
<p>Daarnaast kondigde Woori Bank of Korea de ondertekening van zakelijke overeenkomsten aan met Samsung Securities en SK Securities. De drie bedrijven zijn het eens om gezamenlijk het bedrijfsmodel voor beveiligingsgebaseerde tokens (ST) te verkennen, systeemconformiteit te bereiken, infrastructuur op te bouwen, gedistribueerde grootboeken gezamenlijk te verifiëren en een samenwerkend adviesbureau, Finance 3.0 Partners, te vormen.</p>
<p>Wat betreft gegevens is Bitcoin kortstondig onder de $26.000 gezakt binnen 24 uur en wordt nu genoteerd op $26.154. De daling in 24 uur bedraagt 3,89%, waarmee alle winsten sinds de overwinning van Grayscale worden tenietgedaan.</p>
<p>Arkham-gegevens tonen aan dat de recentelijk populaire friend.tech ook snel begint af te koelen, met een scherpe daling van het dagelijkse handelsvolume van $16 miljoen op 21 augustus tot $700.000 vandaag, een daling van meer dan 95%.</p>
<p>Volgens The Block heeft het Web3-platform sinds 2023 verliezen geleden van maar liefst $1,25 miljard in 211 hackincidenten, waarbij de verliezen veroorzaakt door hacking in augustus meer dan $23 miljoen bedroegen. Sinds de opening van het Base-mainnet voor het publiek op 9 augustus hebben vier projecten aanzienlijke verliezen geleden als gevolg van hacker aanvallen, met <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Chain wordt een van de meest aanglen chains.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag282228"><a name="Belangrijkste Token Trends van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste Token Trends van vandaag</h2><h3 id="h3-BTC17167"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1693547727BTC.png" alt=""><br>De algehele markt sloot af op $25.987 USD in augustus, merkbaar onder de $27.000 USD grens van de sluiting in mei. De voortschrijdende gemiddelden hebben opnieuw een death cross laten zien, wat wijst op een aanstaande correctieve fase op middellange termijn.</p>
<p>Gisteren, nadat het kort stabiliseerde op $26.510 USD, was er een terugtrekking naar $25.606 USD. Op korte termijn wordt verwacht dat het blijft schommelen binnen het bereik van $26.510 USD tot $25.606 USD. Een conservatieve strategie zou kunnen inhouden dat short trades worden gepositioneerd rond $25.606 USD met een doel richting de ondersteuning op $24,2K USD.</p>
<h3 id="h3-ETH330922"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1693547748ETH.png" alt=""><br>De maandelijkse afsluiting voor deze maand werd vastgesteld op het niveau van $1.650 USD. De algehele trend blijft bearish en een retracement naar $1.631 USD werd zonder vooringenomenheid bereikt. Op korte termijn blijft de aandacht gericht op het niveau van $1.631 USD als verdedigingslinie en de bovengrens van het dalende kanaal. Het handhaven van stabiliteit boven de trendlijn is cruciaal voor een mogelijke opleving.</p>
<h3 id="h3-CYBERVEILIGHEID462807"><a name="CYBERVEILIGHEID" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CYBERVEILIGHEID</h3><p><img src="https://gimg2.gateimg.com/image/article/1693547767CYBER.png" alt=""><br>Op de 15-minuten korte termijn grafiek zijn tekenen van een opwaartse momentum te zien, gevolgd door een doorbraak boven de $8.886 USD en een retracement naar $8.185 USD. Opmerkelijk is dat er duidelijke verborgen bullish divergentie is geweest, maar er is aanzienlijke volatiliteit geweest, inclusief een scherpe beweging naar $9.7 USD, gevolgd door een snelle omkering.</p>
<p>Op korte termijn is het duidelijk dat er een spel van vraag en aanbod is zonder substantiële instroom van geld. Het monitoren van de financieringsrente van de contractmarkt blijft essentieel als basis voor het innemen van longposities of het handhaven van een afwachtende benadering. Upside-doelen zijn onder andere $10.479 USD, $12.27 USD, $14.50 USD en $17.79 USD, terwijl het behoud van ondersteuning op $8.145 USD cruciaal is.</p>
<h2 id="h2-Macro20Inflatie20koelt20af20de20Federal20Reserve20kan20doorgaan20met20het20handhaven20van20het20aanscherpingsbeleid226735"><a name="Macro: Inflatie koelt af, de Federal Reserve kan doorgaan met het handhaven van het aanscherpingsbeleid" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Inflatie koelt af, de Federal Reserve kan doorgaan met het handhaven van het aanscherpingsbeleid</h2><p>Gisteravond toonden de nieuwste gegevens van het Amerikaanse ministerie van Handel aan dat de persoonlijke consumptie-uitgaven (PCE) prijsindex in juli is gestegen naar 3,3% op jaarbasis van 3% in juni, in lijn met de marktverwachtingen en het behalen van de grootste jaar-op-jaar groei sinds juni 2022; De maand-op-maand groei was 0,2%, in overeenstemming met de verwachtingen en eerdere waarden.</p>
<p>De favoriete inflatie-indicator van de Federal Reserve, de kern PCE-prijsindex exclusief voedsel en energie, heeft een licht gestegen jaar-op-jaargroei van 4,1% in juni naar 4,2%, in lijn met de verwachtingen van de markt. De maand-op-maand groei van 0,2% is ook consistent met de verwachtingen en eerdere waarden. Dit is de tweede opeenvolgende maand-op-maand groei van 0,2% in de kern PCE-prijsindex, wat in lijn is met de trend van geleidelijk afkoelende inflatie. De reden hiervoor is dat om het inflatiedoel van 2% te bereiken, de inflatie maandelijks met 0,2% moet toenemen (sommige maanden kunnen 0,1% zijn).</p>
<p>De nieuwste uitgebrachte gegevens brengen gemengd nieuws voor de markt: aan de ene kant zijn de inflatie-indicatoren de afgelopen twee maanden licht gestegen, wat de groei van de consumentenbestedingen stimuleert en de kans vergroot dat de Amerikaanse economie een recessie kan vermijden; Aan de andere kant baart de veerkracht van de economie zorgen en heeft de Federal Reserve meer reden om de verkrapping voort te zetten om de inflatie verder te verlagen.</p>
<p>Nadat de gegevens gisteravond waren vrijgegeven, bleef het rendement van benchmark 10-jaars Amerikaanse staatsobligaties, bekend als het “anker van de wereldwijde activaprijzen”, dalen, en het rendement van tweejarige Amerikaanse obligaties, die gevoeliger zijn voor rentetarieven, nam het voortouw bij het herstel, en Amerikaanse aandelen daalden in de ochtend; De Amerikaanse dollarindex heeft zijn winst uitgebreid, brak los van het laagste punt in twee weken van woensdag en zal de week eindigen met zijn eerste stijging; De Amerikaanse aandelenmarkt bleef stijgen, maar de intradag rally nam af, waarbij de belangrijkste aandelenindices op een gegeven moment daalden.</p>
<p>De drie belangrijkste aandelenindexen in de VS zijn schommelend, met de Dow Jones die met 0,48% daalt, de Nasdaq die met 0,11% stijgt, de S&amp;P 500 die met 0,16% daalt, populaire technologieaandelen die stijgen en dalen, Amazon die meer dan 2% stijgt en Intel die bijna 2% stijgt. Vinfast daalde meer dan 16%, met een marktwaarde van $80 miljard. De prijs van spotgoud steeg drie opeenvolgende dagen niet meer en sloot onder de $1.940, met een daling van 0,13% tot $1.939,85 per ounce. Spotzilver daalde twee opeenvolgende dagen en sloot 0,72% lager op $24,43 per ounce.</p>
<p>De marktfocus is verschoven naar het zware werkgelegenheidsrapport dat op vrijdag zal worden vrijgegeven, wat ook de laatste gegevens over de werkgelegenheid buiten de landbouw zijn vóór de volgende vergadering van de Federal Reserve. Gelieve aandachtig te zijn.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Byron B.</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 beleggingsadvies.<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 er juridische actie worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>