RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBkYWFsdCBtZXQgMTAlLCBXYWxsIFN0cmVldCBvbnRodWx0IGRhdCBNdXNrIHppam4gYmV6aXR0aW5nZW4gaW4gQlRDIGhlZWZ0IHZlcm1pbmRlcmQsIGRlIHNjaGFhbCB2YW4gaGV0IEZlZCBiYWxhbnN2ZXJsYWdpbmdzcHJvZ3JhbW1hIHphbCAkMSBiaWxqb2VuIGJlZHJhZ2Vu

2023-08-18, 03:57

<p><img src="https://gimg2.gateimg.com/image/article/16923375230818.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Wall20Street20onthult20dat20Musk20zijn20bezittingen20in20Bitcoin20heeft20verminderd20waardoor20de20markt20met201020is20gedaald20als20reactie282799"><a name="Crypto Daily Digest: Wall Street onthult dat Musk zijn bezittingen in Bitcoin heeft verminderd, waardoor de markt met 10% is gedaald als reactie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Wall Street onthult dat Musk zijn bezittingen in <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> heeft verminderd, waardoor de markt met 10% is gedaald als reactie</h2><p>Vandaag, rond 21:30 uur (UTC), <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> plotseling met meer dan 9% gedaald, met een dieptepunt van $25.409 en $24.715, met een daling van meer dan 9,41% in 24 uur. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> daalde op korte termijn onder de $1.600, met een minimum van $1.551,71. Het handelt momenteel op $1.615,47, een daling van 10,85% in 24 uur.</p>
<p>Deze daling heeft ertoe geleid dat de marktwaarde van Bitcoin voor het eerst sinds 16 juni onder de $500 miljard is gezakt en het laagste punt heeft bereikt sinds 20 juni.</p>
<p>Volgens CoinGlass-gegevens heeft de scherpe daling geleid tot afwikkelingsbedragen van meer dan $1 miljard in de afgelopen 24 uur, een stijging van 737,87% vergeleken met de vorige handelsdag. Dit omvat $472 miljoen aan Bitcoin-afwikkeling en $302 miljoen aan Ethereum-afwikkeling, waarbij het merendeel van de getroffen posities longposities zijn.</p>
<p>De cryptogemeenschap schreef een deel van de dalingen toe aan een rapport in de Wall Street Journal.</p>
<p>Het rapport vermeldt dat het balansoverzicht van SpaceX in 2021-2022 een afschrijving van $373 miljoen aan Bitcoin registreerde, en het exacte tijdstip van verkoop is nog niet duidelijk. Musk vermeldde tijdens een toespraak in 2021 dat SpaceX Bitcoin bezit, maar aangezien het een privébedrijf is, werd het exacte bedrag niet bekendgemaakt.</p>
<p>Daarnaast heeft Tesla, een ander bedrijf van Musk, in het tweede kwartaal van 2022 meer dan 30.000 bitcoins verkocht voor $936 miljoen, wat ongeveer 75% is van zijn oorspronkelijke $1,5 miljard aan bitcoins.</p>
<p>Musk is altijd al een enthousiaste voorstander geweest van cryptocurrencies en in zijn introductie op X social media is er een populaire <a href="/price/dogecoin-doge" rel="nofollow noopener noreferrer" target="_blank">Dogecoin</a> symbool genaamd “Ð.” Zoals bekend zal elk nieuws gerelateerd aan Musk invloed hebben op de markt.</p>
<p>Nog een nieuws dat mogelijk tot verkoop kan leiden, is dat de Chinese vastgoedontwikkelaar Evergrande faillissementsbescherming aanvraagt in de Verenigde Staten, wat zorgen baart onder investeerders dat de problemen in de Chinese vastgoedmarkt zich kunnen verspreiden naar andere sectoren van de mondiale economie.</p>
<p>In de afgelopen weken zijn de prijzen van Bitcoin gedaald, waarbij ongeveer de helft van de stijging na de aanvraag van een Bitcoin ETF door BlackRock op 15 juni is uitgewist.</p>
<p>Volgens Bloomberg is een van de macrofactoren achter de verkoopgolf de voortdurende stijging van de wereldwijde rentetarieven, vooral in de Verenigde Staten, waar het rentetarief van de 30-jarige staatsobligatie steeg naar 4,42%, het hoogste niveau sinds 2011. Het rendement van de 10-jarige staatsobligatie was 4,32, slechts één basispunt lager dan het 15-jarig hoogtepunt. Dit drukt niet alleen de prijs van cryptocurrencies, maar raakt ook risicovolle activa in traditionele markten.</p>
<p>Shiliang Tang, Chief Investment Officer van LedgerPrime, een cryptocurrency-investeringsmaatschappij, verklaarde dat eerder deze week mensen optimistisch waren dat de oplossing voor de Grayscale Bitcoin ETF deze week zou worden geïntroduceerd. Toch werd het uiteindelijk zonder enig resultaat aangenomen. Bovendien zijn de traditionele markten de hele week zwak geweest, waarbij de S&amp;P 500-index en technologieaandelen dalen, 10-jaars rentetarieven hoog zijn, de Amerikaanse dollar stijgt, en zwakke Chinese krediet- en economische gegevens, die allemaal nadelig zijn voor risicovolle activa.</p>
<p>Volgens Kaiko-gegevens is de 90-daagse volatiliteit van Bitcoin en <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> respectievelijk gedaald tot 35% en 37%, terwijl de 90-daagse volatiliteit van ruwe olie 41% heeft bereikt. Volatiliteit is de snelheid waarmee de prijs van een bepaald actief stijgt of daalt binnen een bepaalde periode.</p>
<p>Vanuit historisch perspectief heeft Bitcoin een hoge volatiliteit gehad, wat de laatste tijd niet het g is geweest, maar een scherpe daling in transactievolume heeft deze ongebruikelijke stabiliteit vergezeld. Gegevens tonen aan dat de handelsvolume van Bitcoin vorige maand het laagste niveau heeft bereikt sinds november 2020, met een 30-daagse volatiliteit die een vijfjarig dieptepunt nadert.</p>
<p>Het is vermeldenswaard dat de volatiliteit van Bitcoin momenteel lager is dan die van de S&amp;P 500 index, technologieaandelen, goud, enzovoort.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag739337"><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-BTC749699"><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/1692337565BTC.png" alt=""><br>Beoordeling van de live-uitzending van de shortpositie geplaatst op $28,535 voor BTC, met twee doelniveaus onder $26,500 en $25,620. De aanbevolen shortpositie heeft gerealiseerde winsten/verliezen van 30,63%. Er zou een voortzetting kunnen zijn van een kortetermijndaling, stabiliserend rond $25,750 om een kleine opleving te initiëren. Snelle instap en uitstap worden geadviseerd om kortetermijnoplevingen te benutten.</p>
<h3 id="h3-ETH324128"><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/1692337580ETH.png" alt=""><br>Het beoordelen van de live-uitzending short positie geplaatst op $1815 voor ETH, met twee doelniveaus onder $1755 en $1694. De short positie heeft gerealiseerde winsten/verliezen van 18,40%. Er kan sprake zijn van een voortzetting van een korte termijn neerwaartse beweging, stabiliserend rond $1631,28 om een kleine opleving te initiëren. Snelle instap en uitstap worden geadviseerd om kortetermijnopvang te grijpen.</p>
<h3 id="h3-SEI765722"><a name="SEI" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEI</h3><p><img src="https://gimg2.gateimg.com/image/article/1692337597SEI.png" alt=""><br>Het hoge doel van $0,2605 is bereikt voor SEI, met aanhoudend neerwaarts potentieel richting $0,1668 en $0,1535. Als de korte termijn niet terugtrekt tot $0,1535, kan er verdere neerwaartse beweging zijn. Fibonacci-reeks schattingen voor lagere ondersteuningsniveaus omvatten $0,1433, $0,1362, $0,1290, $0,1202 en het bodemdoel van $0,1060.</p>
<h2 id="h2-Macro20De20schaal20van20balansverkorting20van20de20Fed20zal20120biljoen20bereiken20wat20mogelijk20een20enorme20marktschok20kan20veroorzaken565681"><a name="Macro: De schaal van balansverkorting van de Fed zal $1 biljoen bereiken, wat mogelijk een enorme marktschok kan veroorzaken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De schaal van balansverkorting van de Fed zal $1 biljoen bereiken, wat mogelijk een enorme marktschok kan veroorzaken</h2><p>De Federal Reserve wordt verwacht zijn omvangrijke balans te verkleinen tot $1 biljoen deze maand, wat een belangrijke mijlpaal markeert in zijn poging om jaren van ruim monetair beleid terug te draaien. Beleggers hebben gewaarschuwd dat verdere verkleining van de balans invloed kan hebben op financiële markten.</p>
<p>In de beginfase van de COVID-19 pandemie kocht de Federal Reserve biljoenen dollars aan overheidsobligaties en hypotheek gedekte effecten om het financiële systeem te stabiliseren. Echter, sinds afgelopen lente vervangt de Federal Reserve zijn obligaties niet meer wanneer ze aflopen.</p>
<p>Op 9 augustus, sinds het bereiken van een piek van $8,55 biljoen in mei vorig jaar, is het balanstotaal van de Federal Reserve met $0,98 biljoen gekrompen. Analyse van wekelijkse gegevens laat zien dat deze omvang naar verwachting eind deze maand de $1 biljoen zal overschrijden.</p>
<p>De vermindering van de balans van de Federal Reserve, bekend als kwantitatieve verkrapping (QT), heeft ertoe geleid dat de markt voor staatsobligaties een van zijn grootste kopers is kwijtgeraakt, waardoor het aanbod van schulden dat particuliere beleggers moeten absorberen is toegenomen.</p>
<p>Voor de Federal Reserve kan QT een instabiel pad zijn. De Federal Reserve werd gedwongen zijn poging in 2019 te beëindigen nadat een scherpe stijging van de leenkosten veroorzaakt door een vermindering van de schaal op de markt zorgde voor onrust.</p>
<p>Tot nu toe is de laatste ronde van aanscherping soepel verlopen, hoewel de snelheid bijna twee keer zo hoog is als die van 2018-2019. Beleggers zeggen dat deze veerkracht aangeeft dat het wereldwijde financiële systeem sinds de pandemie is overspoeld met geld. De achtergrond van verdere opschaling wordt echter steeds uitdagender.</p>
<p>Jay Barry, mededirecteur van de Amerikaanse rentestrategie van JPMorgan Chase, zei dat de tweede ronde van vermindering op biljoen dollar mogelijk een grotere impact kan hebben. De eerste vermindering op de schaal van een biljoen dollar was tegen de achtergrond van de snelle stijging van de rente op federale fondsen, en de tweede vermindering op de schaal van een biljoen dollar is belangrijker omdat deze zal plaatsvinden tegen de achtergrond van een versnelde aanbod van Amerikaanse schatkistobligaties.</p>
<p>Het doel van de Federal Reserve is om zijn balans met nog eens $1,5 biljoen te verminderen tegen midden-2025, terwijl de Amerikaanse overheid de omvang van nieuwe obligatie-uitgiftes aanzienlijk verhoogt en de vraag van buitenlandse investeerders ook afneemt.</p>
<p>Dit kan de leenkosten voor overheden en bedrijven verhogen en verliezen veroorzaken voor veel beleggers die dit jaar veel obligaties hebben gekocht. Deze beleggers verwachten dat naarmate de cyclus van renteverhogingen ten einde loopt, de Amerikaanse obligatierendementen zullen dalen.</p>
<p>IMF-senior-econoom Manmohan Singh verklaarde dat een extra $1 biljoen in QT zou overeenkomen met een extra verhoging van 15 tot 25 basispunten in de federal funds rate.</p>
<p>“Naarmate de rentetarieven stabiliseren, kan de impact van meer QT makkelijker te zien zijn,” zei hij.</p>
<p>Het Amerikaanse ministerie van Financiën heeft dit jaar zijn obligatie-uitgifte verhoogd om het gat te vullen tussen een daling van belastinginkomsten en een stijging van de overheidsuitgaven. Eerder deze maand kondigde het ministerie aan dat het de veilingomvang in het volgende kwartaal zou uitbreiden en verder zou uitbreiden in de komende kwartalen. Megan Swiber, een rente-analist bij Bank of America, schatte dat de veilingomvang van sommige obligaties in 2021 het hoogtepunt zou kunnen bereiken toen de leenpiek van de COVID-19-pandemie plaatsvond.</p>
<p>Ondertussen wordt verwacht dat de vraag van Japan, de grootste buitenlandse houder van Amerikaanse staatsobligaties, zal afnemen. De Bank of Japan versoepelde in juli haar controle over de obligatiemarkt van de overheid, waardoor de Japanse obligatierendementen op het hoogste niveau in bijna een decennium kwamen. De hogere obligatierendementen deden sommige investeerders voorspellen dat er veel Japanse fondsen zouden zijn. <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Vloeien</a> terug, inclusief een groot bedrag aan fondsen die uit Amerikaanse schatkist obligaties stromen.</p>
<p>Echter hebben buitenlandse media verklaard dat zelfs in deze situatie wordt verwacht dat een vermindering van de balans niet zal leiden tot de liquiditeitscrisis die zich voordeed in 2019. In tegenstelling tot vier jaar geleden, is er nog steeds een grote hoeveelheid contant geld in het financiële systeem. Ondanks verminderd gebruik absorbeert een speciaal instrument dat is ontworpen door de Federal Reserve om overtollig geld op te nemen nog steeds ongeveer $1,8 biljoen per nacht. Bankreservereisten zijn dit jaar afgenomen, maar ze bevinden zich nog steeds ver boven het niveau waarop de Federal Reserve zich zorgen begint te maken.</p>
<p>Sommige analisten geloven echter dat het rendement van de Amerikaanse schatkist obligatiemarkt mogelijk aanzienlijk zal stijgen, vooral voor langlopende schatkistobligaties.</p>
<p>“De schaalvermindering van de Fed, hoewel passief, zou moeten leiden tot een steilere rentecurve,” zei Barry. “Hoewel de renteverhoging in principe is voltooid, kan de schaalvermindering van de balans de rentecurve beïnvloeden voor de rest van dit jaar en volgend jaar.”</p>
<p>Aangezien het rendement van Amerikaanse schatkistobligaties de waardering van verschillende activaklassen ondersteunt, betekent een scherpe stijging ook dat de kosten voor bedrijfsleningen stijgen en de stijging van de aandelenmarkt dit jaar kunnen ondermijnen.</p>
<p>Scott Skyrm, een repo-handelaar bij Curvature Securities, zei: “Dit alles heeft invloed op kopers, verkopers en de markt. Wanneer een van hen verandert, zal er vaak meer volatiliteit zijn. Ik verwacht dat er meer volatiliteit zal optreden in september en oktober, omdat er meer nieuwe obligatie-uitgiftes zullen 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 mening van de onderzoeker en vormt geen beleggingsadviezen.<br></em><div><em></em>Gate.io behoudt alle rechten van dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt genoemd. In alle glen zal er juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>