RGFnZWxpamtzIG5pZXV3cyB8IE9SREkga2VuZGUgZWVuIGR1YmJlbGUgZXhwbG9zaWUgdmFuIGxvbmctIGVuIHNob3J0bGlxdWlkYXRpZTsgVm9sZyBvcG1lcmtlbGlqa2UgY3J5cHRvdHJlbmRzIGluIDIwMjQ7IEZvbmRzZW4gc3Ryb29tZGVuIHNuZWwgaW4gRXRoZXJldW0tZnV0dXJlcw==

2023-12-07, 04:05

<p><img src="https://gimg2.gateimg.com/image/article/17019301781_5.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20ORDI20maakte20een20dubbele20explosie20van20liquidatie20van20long20en20short20mee20Volg20opmerkelijke20cryptotrends20in202024692670"><a name="Crypto Dagelijkse Samenvatting: ORDI maakte een dubbele explosie van liquidatie van long en short mee; Volg opmerkelijke cryptotrends in 2024" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: ORDI maakte een dubbele explosie van liquidatie van long en short mee; Volg opmerkelijke cryptotrends in 2024</h2><p>Laten we allereerst eens kijken naar de zeer verwachte bespreking van het incident met de ‘Inion Vulnerability’ gisteren.</p>
<p>Gisteren, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Kernontwikkelaar Luke Dashjr plaatste op het X-platform waarin staat dat Inion een kwetsbaarheid in de Bitcoin-kernclient <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Core misbruikt om spamberichten naar de blockchain te sturen. Hij erkende dat er nog steeds zwakke plekken zijn in de Bitcoin Core in de aankomende versie V26 en verwacht dat deze uiteindelijk vóór de volgende versie V27 van volgend jaar zullen worden opgelost.</p>
<p>Luke Dashjr heeft bevestigd in het commentaar van X dat als de eerder bekendgemaakte kwetsbaarheid van Bitcoin Core is opgelost, dit betekent dat Ordinals en BRC-20 niet langer zullen bestaan, en verklaarde dat de “Inie Keten” een haalbare oplossing zou kunnen zijn.</p>
<p>Beïnvloed door dit nieuws daalde ORDI op 6 december verder onder de $42, met een daling van 34% in de afgelopen 8 uur en een daling van 15,4% in 24 uur. Volgens Coinglass-gegevens heeft ORDI in de afgelopen 12 uur $14.9409 miljoen verkocht, op één na alleen BTC (Bitcoin). <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> uitverkocht $13.77 miljoen), waarbij meerdere bestellingen uitverkocht zijn voor ongeveer $9.286 miljoen en short orders uitverkocht zijn voor ongeveer $5.655 miljoen.</p>
<p>Volgens Lookonchain monitoring heeft een enorme walvis mogelijk een tweet gezien van Bitcoin Core-ontwikkelaar Luke Dashjr en alle 59.000 ORDIs (ongeveer $3,54 miljoen) verkocht voordat de daling van ORDI plaatsvond, met een winst van meer dan $2,3 miljoen. Deze persoon heeft op 22 november 65.263 ORDIs (ongeveer $1,3 miljoen) opgenomen van Binance, tegen een prijs van $20 destijds.</p>
<p>Na 12 uur van het gisten van het kwetsbaarheidsincident beantwoordde Luke Dashjr verschillende vragen van sceptici op het X-platform. Een van de vragenstellers zei: ‘Is het mogelijk dat zolang een miner er niet voor kiest om te vertrekken, die miner nog steeds de inietransacties op de blockchain kan afhandelen? Of moeten miners een meerderheidsconsensus bereiken over of ze ervoor kiezen om toe te treden / te vertrekken?’</p>
<p>Luke Dashjr reageerde door te zeggen dat we niet per se alle inschrijvingen hoeven te elimineren om waarde te bieden aan Bitcoin.</p>
<p>De bovenstaande opmerkingen van Luke Dashjr kunnen de inie ‘verzachten’ om de gemeenschap te erkennen, en ORDI is kortstondig met ongeveer 20% gestegen, met een huidige koers van $52.6. Op het moment van schrijven is ORDI weer gestegen boven $55 en wordt nu genoteerd aan $55.28, met een extra stijging van meer dan 30% in het afgelopen uur.</p>
<p>Op 6 december plaatste de bekende crypto-venture capitalist a16z crypto op het X-platform opvallende trends in de crypto-industrie in 2024, waaronder het betreden van een nieuw tijdperk van decentralisatie; Reset toekomstige gebruikerservaring; De opkomst van modulaire technologiestacks; De combinatie van kunstmatige intelligentie en blockchain; P2E (Play to earn) wordt P+E (Play and earn); Wanneer kunstmatige intelligentie een game creator wordt, biedt cryptocurrency zekerheid; Formele verificatie is beknopter geworden; NFT is een alomtegenwoordige merkactiva geworden; SNARK (beknopte niet-interactieve kennisargumentatie) is mainstream geworden.</p>
<p>Naarmate de markt zich herstelt, lijdt de luchtmacht op de cryptobeurs ook zware verliezen.</p>
<p>Volgens Decrypt, blijkt uit het nieuwste rapport van financiële gegevensbedrijf S3 Partners dat sinds Bitcoin op 11 september een dieptepunt van drie maanden bereikte ($25.152), de prijs met 75% is gestegen naar de huidige $43.924. Deze momentum heeft ertoe geleid dat korte termijn crypto handelaren in minder dan drie maanden meer dan $2,6 miljard hebben verloren. Crypto aandelen, vertegenwoordigd door Coinbase en MicroStrategy, stegen in lijn met Bitcoin, waardoor short sellers verrast werden.</p>
<p>Onder de sterke opleving van de Bitcoinprijzen is de aandelenkoers van Coinbase in de afgelopen maand met 51% gestegen, tot $143,63; De aandelenkoers van MicroStrategy, dat ongeveer $6,6 miljard aan Bitcoin bezit, is sinds oktober met 82% gestegen tot $568,88.</p>
<p>Deze enorme schommelingen in de aandelenkoersen hebben ervoor gezorgd dat short traders in crypto-aandelen de afgelopen drie maanden $2,656 miljard hebben verloren, waarbij meer dan 50% van de verliezen afkomstig zijn van short gaan op Coinbase-aandelen en nog eens 25% van short gaan op MicroStrategy-aandelen.</p>
<p>Wat betreft de gegevensschommelingen is BTC deze kwartaal met meer dan 60% gestegen, terwijl ETH slechts met 35% is gestegen. Over een langere periode is het prestatieverschil tussen de twee nog groter.</p>
<p>Sommige analisten geloven dat aangezien fondsen nu <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stromen</a> naar Ethereum-futures op een sneller tempo dan Bitcoin-futures, kan deze kloof smaller worden.</p>
<p>Volgens Velo Data is de USD-waarde van de openstaande posities van CME’s cash-settled Ethereum-futurescontracten in de afgelopen vijf dagen met 30% gestegen, waardoor deze $711 miljoen heeft bereikt, wat de stijging van 19% in openstaande posities van Bitcoin-futurescontracten ($4,9 miljard) overtreft.</p>
<p>Bovendien was volgens de gegevens van Reflexity Research eerder deze week de premie van <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> futures ten opzichte van de spotindexprijzen (meer dan 20%) 5% hoger dan die van Bitcoin. Na de initiële stijging van Bitcoin begonnen de open posities in Ethereum futurescontracten op CME toe te nemen. Tegelijkertijd toont de optie-indicator op Deribit ook een toegenomen bullish voorkeur onder investeerders voor Ethereum.</p>
<h2 id="h2-Belangrijkste20trends20van20vandaag20in20tokens173643"><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-BTC417559"><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/1701930224BTC.png" alt=""><br>Deze week blijft Bitcoin (BTC) stabiliseren rond de $44.000. De kortetermijnhandelsvolumes verminderen vanochtend geleidelijk. Kortetermijndoelen blijven op $45.345 en $47.990. Langetermijn-bullish-doelen zijn ingesteld op $120.400 en $128.350. Er wordt deze maand hoge volatiliteit verwacht, met een potentieel terugtrekking in Q1 volgend jaar.</p>
<h3 id="h3-ETH942952"><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/1701930248ETH.png" alt=""><br>Ethereum (ETH) slaagde er deze week vier keer in om het weerstandsniveau van $2.135 te doorbreken, maar ondervond vanochtend een pullback met volume naar $2.230. Het opwaartse doel is vastgesteld op $2.381, met kortetermijnondersteuning op $2.194 en langetermijnondersteuning op $2.135. Het langetermijn-bullish perspectief omvat doelen van $8.000 en $12.300.</p>
<h3 id="h3-ARKM575945"><a name="ARKM" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ARKM</h3><p><img src="https://gimg2.gateimg.com/image/article/1701930268ARKM.png" alt=""><br>ARKM heeft vijf opeenvolgende bullish wekelijkse kaarsen doorgemaakt, waarbij een retracement van het wekelijkse voortschrijdend gemiddelde is voltooid. De dagelijkse grafiek vormt een grote cup-and-handle structuur, wat wijst op een bullish trend. Korte termijn doelen zijn $0,5916 en de vorige hoogte van $0,8900. Langetermijndoelen zijn onder andere $0,89, $1,25, $1,85 en $2,45, met een potentieel prijsstijging van 845% in de langetermijnopstelling.</p>
<h2 id="h2-Macro20ADPwerkgelegenheidsgegevens20vallen20tegen20en20de20marktsfeer20voor20renteverlagingen20is20sterk612668"><a name="Macro: ADP-werkgelegenheidsgegevens vallen tegen en de marktsfeer voor renteverlagingen is sterk" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: ADP-werkgelegenheidsgegevens vallen tegen en de marktsfeer voor renteverlagingen is sterk</h2><p>De werkgelegenheidsgegevens van ADP in november in de Verenigde Staten registreerden 103.000 mensen, terwijl de markt 130.000 mensen verwachtte, wat voor de vierde opeenvolgende maand achterbleef bij de verwachtingen; De lonen van werkende personen zijn met 5,6% gestegen, het laagste loongroeipercentage sinds september 2021.</p>
<p>Beïnvloed door het lager dan verwachte ADP-rapport en opnieuw het verzwakken van de arbeidsmarkt bevestigend, blijven de Amerikaanse schatkistrendementen dalen, waarbij de 10-jarige Amerikaanse schatkistrendementen de 4,1% naderen, het laagste niveau sinds 1 september, en sluiten op 4,167%; Het rendement op de Amerikaanse schatkist van twee jaar, dat gevoeliger is voor het rentebeleid van de Federal Reserve, gaf al zijn intraday winst op tijdens de handel en sloot uiteindelijk iets hoger op 4,597%.</p>
<p>Naarmate de markt volledig rekening hield met de kans op een renteverlaging door de Federal Reserve en de verwachtingen voor andere centrale banken verder verdiepten, stond de Amerikaanse dollarkoers op 104 en sloot uiteindelijk 0,309% hoger op 103,95. De drie belangrijkste Amerikaanse aandelenindices openden hoog en sloten laag, waarbij de Dow Jones Industrial Average 0,19% lager sloot, de S&amp;P 500-index met 0,39% daalde en de Nasdaq met 0,59% daalde.</p>
<p>Gezien de zwakke Amerikaanse obligatierendementen en de stabilisatie van spotgoud, bereikte het een maximum van $2.035,71 per ounce op de dag en sloot uiteindelijk 0,34% op $2.026,19 per ounce; Spotzilver daalde met $24 per ounce en sloot uiteindelijk 0,92% lager op $23,9 per ounce.</p>
<p>De stijging van de Amerikaanse benzinevoorraden heeft bezorgdheid gewekt over de vraag, waarbij investeerders zich afvragen of de productiebeperkingen van OPEC+ het effect van overaanbod van andere olieproducerende landen en zwakke wereldwijde olievraag kunnen compenseren. Internationale ruwe olie is voor de vijfde opeenvolgende handelsdag gedaald. WTI-ruwe olie zakte voor het eerst sinds begin juli onder de $70-grens en sloot uiteindelijk 4% lager op $69,36 per vat; Brent-ruwe olie sloot 3,5% lager op $74,55 per vat, wat voor het eerst sinds het einde van juni dit jaar onder de $75 per vat is gebleven.</p>
<p>Na de aanzienlijke verhoging van de rentetarieven door de Federal Reserve, koelt de Amerikaanse arbeidsmarkt gestaag af.</p>
<p>Echter verwachten economen over het algemeen dat het non-farm rapport een toename van de werkgelegenheid in november zal laten zien, aangezien ongeveer 33000 stakende leden van de Federatie van Automobielarbeiders weer aan het werk gaan.</p>
<p>Bill Adams, Chief Economist van Commercial Bank of America in Dallas, verklaarde dat de recente verzwakking van de arbeidsmarktgegevens het risico op het herstel van inflatiedruk als gevolg van loon-prijskwesties heeft verminderd, waardoor het voor de Federal Reserve gemakkelijker wordt om in 2024 over te schakelen naar renteverlagingen. We zullen afwachten.</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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal er juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>