RGFnZWxpamtzIG5pZXV3cyB8IEZUWCBpcyBnb2VkZ2VrZXVyZCBvbSB6aWpuIGNyeXB0b2Jleml0dGluZ2VuIHRlIGxpcXVpZGVyZW4sIEV0aGVyZXVtLWZ1dHVyZXNwcmVtaWVzIHppam4gbGFhZywgZGUgY3J5cHRvbWFya3Qga2FtcHQgbWV0IGVlbiBlcm5zdGlnZSBsaXF1aWRpdGVpdHNjcmlzaXM=

2023-09-14, 04:09

<p><img src="https://gimg2.gateimg.com/image/article/16946733030914.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Digest20Het20bekende20online20gamebedrijf20Linekong20Interactive20heeft20een20magazijn20opgericht20en20ongeveer2010020BTCs20gekocht20FTX20is20goedgekeurd20om20zijn20cryptoactiva20te20liquideren30852"><a name="Crypto Dagelijkse Digest: Het bekende online gamebedrijf Linekong Interactive heeft een magazijn opgericht en ongeveer 100 BTC’s gekocht, FTX is goedgekeurd om zijn crypto-activa te liquideren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Digest: Het bekende online gamebedrijf Linekong Interactive heeft een magazijn opgericht en ongeveer 100 BTC’s gekocht, FTX is goedgekeurd om zijn crypto-activa te liquideren</h2><p>Volgens rapporten heeft Linekong Interactive Group Co., Ltd (08267. HK), een in Hong Kong genoteerd bedrijf, aangekondigd dat volgens de bekendmakingen van het bedrijf op 15 juni, 7 juli, 8 augustus en 17 augustus 2023, de groep in totaal 92,4712 eenheden heeft gekocht. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> bij openbare markttransacties, met een totale contante vergoeding van ongeveer $2,66 miljoen.</p>
<p>De aankondiging vermeldt dat de raad van bestuur aanbeveelt om voorafgaande goedkeuring van aandeelhouders te zoeken om bestuurders te machtigen en te machtigen om potentiële cryptocurrency-aankopen te doen tijdens de autorisatieperiode, met een totale overweging van niet meer dan $5 miljoen. De groep merkte ook op dat de prijs van cryptocurrencies aanzienlijk kan fluctueren, dus de raad van bestuur is geïnteresseerd in investeren in de grootste cryptocurrencies naar marktwaarde, zoals <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>MetaMask heeft een nieuwe functie aangekondigd genaamd Snaps, waarmee het kan worden uitgebreid naar niet-EVM ketens zoals Cosmos. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, en Starknet. Snaps is een softwaremodule die geïntegreerd kan worden met MetaMask, waardoor portefeuilles over ketens heen gebruikt kunnen worden.</p>
<p>Volgens Coindesk heeft een rechter in het district Delaware een bevel goedgekeurd waarmee het failliete cryptocurrency handelsplatform FTX zijn $3,4 miljard aan cryptocurrency mag verkopen en investeren. Het plan geeft aan dat de meeste tokens slechts voor $100 miljoen per week verkocht kunnen worden, maar de bovengrens voor elke token kan permanent verhoogd worden naar $200 miljoen. Bij de verkoop van Bitcoin, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> en andere tokens moeten regelgevende instanties het Amerikaanse Trustee Office ten minste 10 dagen van tevoren op de hoogte stellen.</p>
<p>Volgens het laatste nieuws heeft FTX zijn voorstel herzien om miljarden dollars aan cryptocurrency-activa te verkopen, maar gezien de mogelijke impact van de transactie op de markt, staat in het herziene voorstel nog steeds dat FTX geen handelsaankondiging vooraf zal doen.</p>
<p>In de afgelopen weken hebben Ethereum futures, in vergelijking met Bitcoin futures, een lagere premie gehad en het verschil is de afgelopen week blijven toenemen.</p>
<p>In vergelijking met de spotmarkt worden Ethereum futures momenteel met korting verhandeld. Dit geeft aan dat de Chicago Mercantile Exchange (CME) een uitzonderlijk pessimistisch vooruitzicht heeft getoond met het oog op Ethereum futures ETF-verwachtingen.</p>
<p>Cryptocurrency onderzoeksbureau K33 Research zei: “vanwege de verwachte notering van Ethereum futures ETF’s in oktober, wat als positief nieuws wordt beschouwd, lijkt de huidige prijsprestatie van Ethereum futures een beetje vreemd. Er zijn geen andere tekenen dat Ethereum ETF’s zullen worden afgewezen, en historisch gezien is het verschil tussen Ethereum en Bitcoin futures geen zorg.”</p>
<p>Volgens het laatste rapport van Glassnode, een bedrijf dat marktanalyse doet voor crypto, heeft de cryptomarkt momenteel te maken met een ernstige liquiditeitscrisis waarbij zowel on-chain als off-chain handelsvolumes historische dieptepunten bereiken. Analisten wijzen erop dat hoewel Bitcoin en Ethereum sinds het begin van dit jaar een nettokapitaalinstroom hebben gekend, alle drie de activa sinds eind augustus zijn teruggekeerd naar neutrale of negatieve instroom, wat duidt op stagnatie en onzekerheid.</p>
<p>De on-chain indicatoren van Glassnode tonen aan dat het totale handelsvolume van Bitcoin-transacties in dollars is gedaald naar een dagelijks gemiddelde van $2,44 miljard, wat hetzelfde niveau is als in oktober 2020. In de off-chain derivatenmarkt heeft het dagelijkse handelsvolume van Bitcoin ook een historisch dieptepunt bereikt, en is voor de eerste keer sinds het dieptepunt in 2022 gedaald tot $12 miljard.</p>
<p>Ondanks de neergang van de markt blijft de vasthoudende trend sterk. Glassnode definieert de groep langetermijnhouders als een on-chain entiteit die tokens langer dan 155 dagen vasthoudt, waarbij de holdings van de groep een historisch hoogtepunt van 14,7 miljoen Bitcoins bereiken. Ondertussen is het aanbod van korte-termijnhouders (minder dan 155 dagen vasthouden) gedaald tot het laagste niveau sinds 2011.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens512545"><a name="Belangrijkste trends van vandaag in tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends van vandaag in tokens</h2><h3 id="h3-BTC481815"><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/1694673357BTC.png" alt=""><br>De algehele trend behoudt nog steeds een zijwaartse handelsstructuur, en om 8:00 uur vanochtend raakte het precies het keerpunt van de neerwaartse trend, en bereikte het de top van het handelsbereik op $26.510. Als de kortetermijn neerwaartse structuur aanhoudt, zal dit keerpunt de beste positie zijn om short te gaan. Blijf de ondersteuningsniveaus binnen het handelsbereik in de gaten houden.</p>
<h3 id="h3-ID873811"><a name="ID" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ID</h3><p><img src="https://gimg2.gateimg.com/image/article/1694673380ID.png" alt=""><br>De grafiek van vier uur is gedaald van zijn all-time high van $0.8445 naar $0.2070. Op korte termijn vormt zich een convergerende driehoek op laag niveau, wat waarschijnlijk wijst op een uitbraak aan het einde van deze maand (mogelijk eerder). De huidige prijs bevindt zich in een mid-axis structuur. Een conservatieve strategie suggereert om in te stappen bij de ondersteuning van de trendlijn, met winstdoelen geschat op $0.2425 tijdens een herstel. Het belangrijkste ondersteuningsniveau bevindt zich op $0.1680.</p>
<h3 id="h3-TRB533525"><a name="TRB" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TRB</h3><p><img src="https://gimg2.gateimg.com/image/article/1694673414TRB.png" alt=""><br>Op korte termijn ondergaat het vieruursdiagram nog steeds consolidatie op hoge niveaus, maar de algehele trend neigt naar een bullish structuur. Gisteren werd twee keer $29,32 getest op het hoogtepunt en snel teruggetrokken naar $23,35, precies terugkerend naar het einde van een convergerende driehoek. Naar schatting ondergaat de markt nog steeds consolidatie. Korte-termijn ondersteuning bevindt zich op $29,32, en de doelen zijn respectievelijk $31,95, $33,61, $34,95, en $36,29.</p>
<h2 id="h2-Macro20CPI20voldoet20aan20verwachtingen20de20Federal20Reserve20zal20mogelijk20niet20langer20de20rente20verhogen664080"><a name="Macro: CPI voldoet aan verwachtingen, de Federal Reserve zal mogelijk niet langer de rente verhogen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: CPI voldoet aan verwachtingen, de Federal Reserve zal mogelijk niet langer de rente verhogen</h2><p>De niet-seizoensgebonden geannualiseerde CPI van de Verenigde Staten bereikte in augustus 3,7%, een nieuw hoogtepunt sinds mei van dit jaar, en is voor de tweede opeenvolgende keer gestegen; De niet-seizoensgebonden geannualiseerde kern-CPI van de Verenigde Staten bedroeg in augustus 4,3%, wat een nieuw laagtepunt is sinds september 2021 en al zes opeenvolgende maanden daalt; Na de kwartaalaanpassing in augustus bereikte het maandelijkse CPI-tarief in de Verenigde Staten een nieuw hoogtepunt van 0,6% sinds juni 2022. Het kern-CPI-tarief steeg met 0,3% ten opzichte van juli, wat de eerste versnelde stijging in zes maanden markeerde. Na de publicatie van de kern-CPI-gegevens is de markt inzet voor het verhogen van de rentetarieven door de Federal Reserve vóór november toegenomen.</p>
<p>Economen verwachten dat de consumentenprijzen in augustus met 0,6% op maandbasis en 3,6% op jaarbasis zullen stijgen. Dit zal hoger zijn dan de stijging van 0,2% op maandbasis in juli en de stijging van 3,2% op jaarbasis. Maar als volatiele voedsel- en energieprojecten worden uitgesloten, verwachten deze economen dat de zogenaamde kernprijzen in augustus met 0,2% op maandbasis zullen stijgen, dezelfde snelheid als juni en juli - een periode van relatief milde gegevens in vergelijking met eerdere maanden.</p>
<p>Economen schatten dat de kern-CPI in augustus op jaarbasis met 4,3% is gestegen, een vertraging ten opzichte van de stijging van 4,7% op jaarbasis in juli. De afkoeling van de kerninflatie deze zomer heeft de basis gelegd voor de Federal Reserve om volgende week de rentestabiliteit te handhaven, en de CPI-gegevens van augustus zullen een referentie vormen voor de Federal Reserve om te bespreken of het nodig is om later dit jaar de rente opnieuw te verhogen. De Federal Reserve heeft meer dan een jaar lang agressief de rente verhoogd in een poging om de inflatie te verlagen door de economische groei te vertragen.</p>
<p>Alleen al uit de gegevens van gisteravond blijkt dat er gemengde gevoelens zijn. Hoewel het jaarlijkse CPI-tarief hoog is, voldoet de kern-CPI nog steeds aan de verwachtingen. In deze situatie is er natuurlijk niet te veel volatiliteit op de markt, zoals we kunnen zien aan de aandelenmarkt. De drie belangrijkste aandelenindices in de VS zijn fluctuerend, waarbij de Dow 0,2% daalt, de Nasdaq 0,29% stijgt en de S&amp;P 500-index 0,12% stijgt.</p>
<p>Bovendien verklaarden enkele grote Amerikaanse obligatiebeleggers op woensdag dat ondanks de stijging van de energieprijzen die leidt tot toenemende inflatie in augustus, zij van mening zijn dat de Federal Reserve het hoogtepunt van renteverhogingen heeft bereikt.</p>
<p>De Federal Reserve verhoogde de rentetarieven met 25 basispunten in juli. De weddenschappen op de markt voor federal funds futures tonen aan dat handelaren over het algemeen geloven dat de Federal Reserve de rentetarieven ongewijzigd zal laten aan het einde van de FOMC-vergadering op 20 september. Echter, woensdagavond werd 40% van de markt geprijsd voor de mogelijkheid van nog eens 25 basispunten stijging in november.</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 visie van de onderzoeker en vormt geen beleggingssuggesties.<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 stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>