RGFnZWxpamtzIG5pZXV3cyB8IEJUQyBoZWVmdCBoZXQgcG90ZW50aWVlbCBvbSB0ZSBoZXJzdGVsbGVuLCBtYXJrdGFhbmtvcGVuIGJsaWp2ZW4gc3Rlcms=

2024-10-24, 04:41

<p><img src="https://gimg2.gateimg.com/image/article/172974470210.24.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20BTC20ETFs20hervatten20grote20nettostromen20SHAR20stortte20in20door20interne20verkopen328486"><a name="Crypto Dagelijkse Samenvatting: BTC ETF’s hervatten grote nettostromen, SHAR stortte in door interne verkopen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: BTC ETF’s hervatten grote nettostromen, SHAR stortte in door interne verkopen</h2><p>Volgens de gegevens van Farside Investor, de VS <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Spot ETF’s hadden gisteren een nettostroom van $190 miljoen. IBIT had een nettostroom van $315 miljoen en ARKB had een nettostroom van $99 miljoen. Gisteren was er een kleine nettostroom van $1,26 miljoen naar de VS. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> spot ETF.</p>
<p><strong>Handelaar: Of Trump of Harris wint, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> zal stijgen naar $80.000</strong></p>
<p>Volgens CoinDesk verklaarden sommige handelaren dat het niet uitmaakt welke kandidaat de President van de Verenigde Staten wordt, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> (BTC) kan in de komende weken zijn vorige hoogtepunten doorbreken, wat een verandering in houding markeert voor de verkiezingen van 5 november.</p>
<p>Handelaren geloven al geruime tijd dat de overwinning van de Republikein Donald Trump een positieve factor zal zijn voor de industrie, aangezien hij cryptocurrency ondersteunt en belooft de Verenigde Staten uit te bouwen tot een <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Aan de andere kant heeft de Democraat Kamala Harris geen soortgelijke toezeggingen gedaan, maar verklaarde zij dat zij regelgeving zal invoeren om specifieke groepen te beschermen.</p>
<p>Deze posities hebben mensen over het algemeen doen geloven dat de overwinning van de Republikeinen gunstiger is dan die van Bitcoin. Sommige mensen geloven echter dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> naar verwachting zal stijgen vanwege verschillende macro-economische factoren.</p>
<p><strong>Een insider verkocht 50% van het totale aantal AANDEEL in een transactie, waardoor een prijscrash ontstond en een winst van $2,4 miljoen werd behaald</strong></p>
<p>Volgens Lookonchain monitoring verkocht een insider 500 miljoen SHARs (50% van het totale aanbod) in een transactie voor 19.620 SOLs (ongeveer $3,38 miljoen), waardoor de prijs van SHARs met 96% instortte.</p>
<p>De insider gebruikte 5.710 SOLs (ongeveer $948.000) in 16 portefeuilles voor het snipen, verkreeg 665,6 miljoen SHARs (66,56% van het totale aanbod) en distribueerde ze naar meer dan 100 portefeuilles.</p>
<p>Vier uur geleden verzamelde het 500 miljoen SHARs van 104 portefeuilles en verkocht ze allemaal in één operatie, wat resulteerde in 13.910 SOLs (ongeveer $2,4 miljoen) verdienen.</p>
<p><strong>Bloomberg: BTC-optiemarktgegevens tonen aan dat handelaren momenteel meer geneigd zijn tot bullish</strong></p>
<p>Volgens Bloomberg zei Yev Feldman, mede-oprichter van SwapGlobal: “We zien handelaren call opties kopen rond $68.000 en put opties rond $66.000 in Bitcoin. Met andere woorden, veel mensen blijven posities opbouwen en herbouwen in de hoop om door te breken in een van beide richtingen. Echter, na de verkiezingen zijn de redenen voor de daling beperkt, dus de stijging is meer betekenisvol.”</p>
<p>Volgens gegevens samengesteld door Deribit toont de verhouding van putopties tot callopties een neerwaartse trend aan het einde van het jaar, waarbij meer handelaren callopties kopen dan putopties. De open contracten (d.w.z. totale open contracten) van callopties die aflopen op 29 november zijn geconcentreerd rond $80.000, terwijl de open contracten van callopties die aflopen op 27 december geconcentreerd zijn rond $100.000 en $80.000.</p>
<p>David Lawant, hoofd onderzoek bij cryptocurrency makelaar FalconX, zei: “Ik geloof dat de marktconsensus is dat Bitcoin waarschijnlijk goed zal presteren ongeacht de verkiezingsuitslag. De optieactiviteit rond de komende verkiezing toont een duidelijke opwaartse trend, wat aangeeft dat investeerders meer geneigd zijn om de optiemarkt te gebruiken als een instrument om potentieel opwaarts potentieel te behalen dan als een hedge tegen neerwaartse risico’s.”</p>
<h2 id="h2-Markttrends20POPCAT20blijft20een20nieuw20historisch20hoogtepunt20bereiken20GOAT20blijft20scherp20stijgen667555"><a name="Markttrends: POPCAT blijft een nieuw historisch hoogtepunt bereiken, GOAT blijft scherp stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markttrends: POPCAT blijft een nieuw historisch hoogtepunt bereiken, GOAT blijft scherp stijgen</h2><h3 id="h3-Markt20Hotspots350847"><a name="Markt Hotspots" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Markt Hotspots</h3><p>De sterke prestaties van SOL-prijzen hebben geleid tot de collectieve stijging van <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Chain projecten zoals BOME, POPCAT, JUP, JTO, enz. POPCAT heeft opnieuw een historisch hoogtepunt bereikt, met een marktkapitalisatie van $1.5 miljard, waarmee het de grootste cat meme coin is op basis van marktkapitalisatie, ver voor op andere cat meme coins zoals MEW en MANEKI.</p>
<p>Het Oracle-protocol DIA steeg met 15%, waarbij de DIA-prijzen sinds september met meer dan 400% zijn gestegen. De huidige circulerende marktkapitalisatie van DIA is $135 miljoen, wat een zekere opwaartse potentie heeft in vergelijking met de marktkapitalisatie van het toonaangevende protocol. <a href="/price/link-ln" rel="nofollow noopener noreferrer" target="_blank">LINK</a>, wat $7 miljard is;</p>
<p>GOAT, het toonaangevende AI-meme-token in de keten, blijft stijgen en heeft de afgelopen 4 dagen een stijging van 300% bereikt. De huidige circulerende marktkapitalisatie van GOAT is $ 630 miljoen, wat al het plafond is voor veel meme-munten die nog niet op reguliere beurzen zijn genoteerd. Of GOAT de grens van $ 1 miljard kan doorbreken, vereist het lanceren van meer reguliere handelsplatforms.</p>
<h3 id="h3-Mainstream20Munten885291"><a name="Mainstream Munten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mainstream Munten</h3><p>BTC bevindt zich in een smalle fluctuatiebereik, met BTC die op een gegeven moment daalde tot ongeveer $65.250, maar nu weer boven $67.250 stuitert. BTC ETF blijft grote instromen van $190 miljoen ontvangen, wat wijst op sterke marktkopen;</p>
<p>ETH veerde op nadat het drie opeenvolgende dagen was gedaald tot $2.450. De aandacht van de markt voor ETH is aanzienlijk afgenomen en de ETH/BTC-wisselkoers heeft een nieuw dieptepunt bereikt sinds april 2021;</p>
<p>Altcoins vielen over het algemeen terug, waarbij Layer2-token SCR met 20% daalde en HMSTR, het ‘click-to-earn’ spel op de Ton Chain, ook met 12% daalde.</p>
<h2 id="h2-Macroeconomie20Amerikaanse20aandelen20sluiten20gezamenlijk20lager20financieel20rapport20Tesla20Q320valt20tegen316408"><a name="Macroeconomie: Amerikaanse aandelen sluiten gezamenlijk lager, financieel rapport Tesla Q3 valt tegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomie: Amerikaanse aandelen sluiten gezamenlijk lager, financieel rapport Tesla Q3 valt tegen</h2><p>De drie belangrijkste indexen van de Amerikaanse aandelenmarkt sloten gezamenlijk lager. De S&amp;P 500-index daalde met 0,92% tot 5.797,42 punten; de Dow Jones Industrial Average daalde met 0,96% tot 42.514,95 punten; de Nasdaq-index daalde met 1,63% tot 18.276,65 punten. Het benchmark 10-jaars rendement op staatsobligaties bedraagt 4,24%, terwijl het 2-jaars rendement op staatsobligaties, het meest gevoelig voor het rentebeleid van de Federal Reserve, 4,07% bedraagt.</p>
<p>Sinds het begin van deze week hebben verschillende functionarissen van Europese en Amerikaanse centrale banken opgeroepen tot voorzichtige renteverlagingen, en de markt is begonnen met het heroverwegen van zijn toekomstige beleidstraject. De stijging van de Amerikaanse obligatierendementen blijft de prestaties van risico-activa onderdrukken. Naarmate de Amerikaanse presidentsverkiezingen naderen, heeft Trump’s overeenkomst opnieuw de markt overspoeld, en de sterke Amerikaanse economische gegevens hebben ook de verwachtingen van de Federal Reserve voor toekomstige renteverlagingen verzwakt, zowel dit jaar als volgend jaar. De Europese Centrale Bank is ook voorzichtig geworden, met besluitvormers verdeeld over de vraag of de rentetarieven in december aanzienlijk moeten worden verlaagd, en president Lagarde roept op tot ‘voorzichtigheid’. ‘s Nachts sloten de belangrijkste Europese aandelenindices gezamenlijk lager af.</p>
<p>Brent Schutte, Chief Investment Officer van Northwestern Mutual, wees erop dat dit allemaal te wijten is aan de impact van hoge rentetarieven. De markt herprijs de mogelijkheid van een grote renteverlaging door de Federal Reserve. Sommige economische sectoren hebben nog geen impact van de renteverhoging gevoeld, maar hoe langer de rentetarieven hoog blijven, hoe meer deze sectoren zich moeten aanpassen aan deze realiteit, en de economie is al onevenwichtig. De meest gewaardeerde Amerikaanse aandelen zijn large-cap aandelen, en vanwege het aanhoudende risico op economische recessie kan de markt een kortetermijndownturn ervaren.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Icing</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 enkele beleggingsaanbeveling. Alle investeringen brengen inherente risico's met zich mee; verstandige besluitvorming is essentieel.<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 zullen juridische stappen worden ondernomen bij inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>