RGFnZWxpamtzIG5pZXV3cyB8IE92ZXJ6aWNodCB2YW4gQlRDIEVURiBNaXgtdXAgSW5jaWRlbnQsIE1laXR1IENvbXBhbnkga2FuIEJUQyB2ZXJrb3BlbiwgRGUgdnJhYWcgbmFhciBFdGhlcmV1bSBTdGFraW5nIG5lZW10IGFm

2023-10-17, 04:43

<p><img src="https://gimg2.gateimg.com/image/article/16975243361017.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20Beoordeling20van20Bitcoin20ETF20mixup20incident20Meitu20kan20Bitcoin20verkopen20op20een20geschikt20moment333369"><a name="Crypto Dagelijks Overzicht: Beoordeling van Bitcoin ETF mix-up incident, Meitu kan Bitcoin verkopen op een geschikt moment" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: Beoordeling van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF mix-up incident, Meitu kan Bitcoin verkopen op een geschikt moment</h2><p>Laten we eerst kijken naar het grootste nieuws van gisteren, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF mix-up incident.</p>
<p>Cointelgraph meldde dat de Amerikaanse SEC de iShares Bitcoin spot ETF van BlackRock heeft goedgekeurd, maar dit werd later in twijfel getrokken door Bloomberg-analisten James Seyfart en anderen. Kort daarna tweette Fox Business-journalist Eleanor Terrett: ‘BlackRock heeft zojuist bevestigd dat dit (mediaclaims dat de ETF-aanvraag is goedgekeurd) onjuist nieuws is. Hun (Bitcoin spot ETF)-aanvraag is nog steeds in behandeling.’</p>
<p>Ondertussen brak de prijs van Bitcoin door $30.000, met een korte termijn stijging van meer dan 10%. Na het nieuws dat Bitcoin spot ETF’s waren goedgekeurd, werd vervalst, zakte BTC weer onder $28.000. Binnen één uur (van 21:00 tot 22:00 uur, Peking-tijd, gisteravond) overschreed de blootstelling van het hele netwerkcontract van de cryptomarkt $100 miljoen.</p>
<p>Cointelgraph heeft vervolgens de tweet ‘SEC keurt Bitcoin spot ETFs goed’ verwijderd en excuses aangeboden waarin staat dat er een intern onderzoek gaande is. Uit de onderzoeksresultaten blijkt dat het valse nieuws over de Bitcoin spot ETF afkomstig was van een onbevestigde screenshot die door een X-gebruiker werd vrijgegeven, die beweerde dat de screenshot afkomstig was van een Bloomberg-terminal. Cointelgraph heeft de bron van het bericht niet geverifieerd voordat deze informatie per abuis op X werd geplaatst.</p>
<p>Vervolgens verklaarde de Amerikaanse Securities and Exchange Commission (SEC) officieel: “Wees voorzichtig met informatie op internet. De beste bron van informatie over de SEC is de officiële website van de SEC.”</p>
<p>Coinbase verklaarde in een onderzoeksrapport op vrijdag dat de wachtrij van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Het aantal blockchain-validatoren is voor het eerst sinds de upgrade van Shanghai in mei leeggemaakt, wat aangeeft dat de vraag van investeerders naar <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> (ETH) staking aan het stabiliseren is.</p>
<p>Het rapport stelt dat met de piek van verifiers in de afgelopen maanden, het stakingsrendement is gedaald van meer dan 5% naar 3,5%. Als de basisactiviteiten en transactiekosten op internet consistent blijven, wordt verwacht dat het stakingsrendement stabiel zal blijven vanwege een vertraging in de groei van validators. Bovendien geeft het rapport aan dat de activiteit op het hoofdnetwerk van Ethereum stabiel bleef in het derde kwartaal, terwijl het totale handelsvolume toenam.</p>
<p>Het rapport voegt toe: “Vanwege het ontbreken van significante upgrades van het Ethereum-protocol vóór Denchun (die waarschijnlijk in de eerste helft van 2024 zullen plaatsvinden), geloven we dat er geen significante technologische drijfveren zijn die een betekenisvolle impact zullen hebben op on-chain activiteiten, tenzij er significante nieuwe protocollen of ernstige hacker aanvallen zijn.”</p>
<p>Volgens een rapport van Sing Tao Daily heeft Meitu eerder gemeld dat het verlies winst winst winst was geworden. Meitu Senior Investor Relations Manager Kang Yicong wees erop dat de winst grotendeels toe te schrijven was aan het abonnementensysteem van het bedrijf, waardoor aanzienlijke schommelingen in de bedrijfswinst als gevolg van macro-economische veranderingen werden vermeden. De recentelijk populaire AI-business is ook de drijvende kracht achter de groei van Meitu, die niet alleen helpt abonnementen te stimuleren, maar ook verwacht dat de winstbijdrage blijft toenemen. Wat betreft cryptoinvesteringen waar de markt zich zorgen over maakt, onthulde ze dat het bedrijf zich niet langer richt op het kopen van dergelijke activa, of ze op een geschikt moment zal verkopen.</p>
<p>Kang Yi-chong gelooft dat AI grotendeels heeft bijgedragen aan de ontwikkeling van het bedrijf, vooral aan de conversie van abonnementsleden. Ze verklaarde dat de bijdrage van AI aan de winst van het bedrijf zal blijven toenemen vanaf de tweede helft van het jaar tot volgend jaar. Het bedrijf heeft sinds 2021 geen cryptocurrency meer gekocht. Ze verklaarde dat de aankoop een strategische overweging was en dat er geen verdere acties zijn ondernomen. Ze benadrukte dat de huidige strategische focus van het bedrijf ligt op het produceren van beelden.</p>
<p>Gisteren, na uitgebreide discussies op het DAO-forum en stemming in de gemeenschap, zal Lido niet langer ondersteunen. <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> (SOL) staking wordt stopgezet en ondersteunt vanaf 16 oktober geen nieuwe SOL-staking meer. Node operators zullen op 17 november stoppen. Vanaf 4 februari 2024 wordt de Lido front-end ondersteuning voor <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> beëindigd. Hierna kan het annuleren van staking alleen nog via de command line interface (CLI). Lido verklaarde dat stSOL-houders nog steeds staking rewards kunnen ontvangen tijdens deze periode.</p>
<p>Volgens het blockchainrapport van Wu Shuo daalde het handelsvolume voor spot trading van de belangrijkste handelsplatforms op de cryptomarkt met 19,3% op maandbasis in september, waarmee het laagste niveau werd bereikt sinds oktober 2020.</p>
<h2 id="h2-Belangrijkste20trends20in20tokens20van20vandaag24484"><a name="Belangrijkste trends in tokens van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends in tokens van vandaag</h2><h3 id="h3-BTC782269"><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/1697524367BTC.png" alt=""><br>Prijzen worden gemanipuleerd en nieuws wordt ook door mensen ontworpen. Zoals vermeld in de live-uitzending, zal er deze week een lichte rebound zijn, met de doelkoers ingesteld op $30.726, net iets onder de hoogste prijs van het contract van $30.720. Het doel om winst te nemen is opzettelijk ingesteld op het ontworpen weerstandsniveau.</p>
<p>Ongeacht of de SEC de BTC ETF in de nabije toekomst goedkeurt, zal deze uiteindelijk worden beoordeeld en goedgekeurd; het is slechts een kwestie van tijd. Op korte termijn is het een punt voor zowel long- als shortposities. Het wordt aanbevolen om te kijken of de RSI hoger is dan 67. Als het boven dit niveau stijgt, samen met de MACD-gouden kruising, blijf dan bullish en mik op een herstest van $29,5K; anders kan het dalen.</p>
<h3 id="h3-ETH420489"><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/1697524386ETH.png" alt=""><br>Gisteren was er, samen met de algehele markt, een aanzienlijk herstel, maar de korte termijn en algehele hersteltrend blijft zwak. Hoewel het hersteldoel van $1.631 werd bereikt, ligt het nu weer onder het weerstandsniveau van $1.594, wat wijst op een voortdurende daling van het totale handelsvolume. Het belangrijkste ondersteuningsniveau op middellange termijn blijft $1.465.</p>
<h3 id="h3-BIGTIME173834"><a name="BIGTIME" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BIGTIME</h3><p><img src="https://gimg2.gateimg.com/image/article/1697524402BIGTIME.png" alt=""><br>Vorige week werden posities ingesteld op twee prijsniveaus: $0,07140 en $0,09350. Korte termijn strategieën kunnen uitstappen voor winst, terwijl middellange tot lange termijn strategieën kunnen blijven vasthouden en trailing stops kunnen gebruiken om winsten veilig te stellen. De korte termijn trend wordt verwacht te pieken op 19 oktober (Beijing Standard Time), mogelijk resulterend in de tweede golf van aanvallen tegen het einde van deze maand.</p>
<p>Vandaag en morgen wordt verwacht dat de neerwaartse trend zal aanhouden en het wordt aanbevolen om boven het laagste punt van de vorige dag van $0.18450 te blijven. Naarmate de kapitaalstructuur groeit, zal de omvang van de korte termijn trend kleiner zijn. BIGTIME heeft veel aandacht getrokken op de markt en zoals gisteren vermeld, kan dit leiden tot een stijging in de leidende blockchain gaming sector.</p>
<h2 id="h2-Macro20Amerikaanse20aandelen20herstellen20black20swangebeurtenissen20blijven20toenemen20en20de20toekomstige20markt20van20Bitcoin20is20veelbelovend639493"><a name="Macro: Amerikaanse aandelen herstellen, black swan-gebeurtenissen blijven toenemen en de toekomstige markt van Bitcoin is veelbelovend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Amerikaanse aandelen herstellen, black swan-gebeurtenissen blijven toenemen en de toekomstige markt van Bitcoin is veelbelovend</h2><p>Dit jaar bleef het FOMC Voting Committee en Philadelphia Fed-voorzitter Huck volhouden dat de Federal Reserve niet verder moet overwegen om de rente te verhogen. Men verwacht dat de inflatie zal verzwakken, en de futuresmarkt verwacht dat de kans dat de rente in november niet wordt verhoogd, meer dan 90% zal bedragen, terwijl de kans op renteverhoging in december slechts 30% is. De Amerikaanse dollarkoers daalde en sloot 0,32% lager op 106,21.</p>
<p>Terwijl geopolitieke risico-hedgers vorige vrijdag winst namen, stegen de Amerikaanse obligatierendementen, waarbij de rendementen op 10-jarige Amerikaanse obligaties met 10 basispunten stegen tot bijna 4,7%, en de rendementen op 2-jarige Amerikaanse obligaties met meer dan 4 basispunten stegen tot 5,1%.</p>
<p>Spot goud daalde lichtjes als gevolg van het herstel van de marktrisicobereidheid, daalde op een gegeven moment boven het niveau van $1910 en sloot 0,63% lager op $1920,16 per ounce. Spot zilver sloot 0,39% lager op $22,61 per ounce.</p>
<p>Het risicobereidheid van Amerikaanse aandelen is hersteld, met de Dow Jones Industrial Average tot 0,93%, de Nasdaq tot 1,2% en de S&amp;P 500-index tot 0,99%. De digitale valutasector zag aanzienlijke winsten, waarbij zowel MicroStrategy als Coinbase met meer dan 2% stegen.</p>
<p>Laten we snel de laatste informatie over het Israëlisch-Palestijnse conflict bekijken:</p>
<p>Iran beweert dat er niet veel tijd meer is voor een politieke oplossing van het conflict en dat uitbreiding van het conflict naar andere fronten onvermijdelijk kan zijn; Geloofd wordt dat de Verenigde Staten militair hebben ingegrepen in het conflict; Het Israëlische leger verklaarde dat gepantserde voertuigen en grondtroepen klaar staan om de Gazastrook binnen te gaan; Tijdens het bezoek van Antony Blinken klonk er een luchtalarm en ging hij vijf minuten in de bunker schuilen; Amerikaanse media: De Amerikaanse minister van Defensie gaf het bevel om zich voor te bereiden op inzet.</p>
<p>Israëlische media meldden dat een 2000-koppige Amerikaanse Marine Rapid Response Force onderweg is naar de kustwateren van Israël; de Israëlische premier verklaarde dat het conflict nog lang kan duren en dat er geen wapenstilstand zal zijn totdat Hamas is geëlimineerd. Zowel Israël als Hamas hebben berichten over een tijdelijke wapenstilstand ontkend; Er heeft een terroristische aanslag plaatsgevonden in het centrum van de Belgische hoofdstad Brussel, duizenden kilometers verderop. De Belgische regering heeft het Brussels Hoofdstedelijk Gewest op het hoogste waakzaamheidsniveau verklaard.</p>
<p>Naarmate het conflict escaleert, moeten we naast het begrijpen of de oorlog de risico’s verder heeft vergroot, meer aandacht besteden aan onze eigen veiligheid. Waar je ook bent, ik geloof dat naarmate de situatie zich verspreidt, sommige extremisten op extreme manieren schade zullen toebrengen aan mensen over de hele wereld. De terroristische aanslag in Brussel gisteren in Billy was een voorbeeld. Iedereen moet letten op veiligheid en proberen plaatsen waar extremisten zich concentreren te vermijden.</p>
<p>Bovendien denk ik dat iedereen op de hoogte is van het nepnieuws over de Bitcoin-spot-ETF die gisteravond werd goedgekeurd. Omdat deze zaak te groot was, stuurde iedereen het direct door zonder het te controleren, wat snel een kettingreactie vormde en leidde tot een scherpe stijging van de marktprijzen, waardoor ze direct naar het niveau van $30.000 werden getrokken. Het duurde echter niet lang voordat de markt terugkeerde naar de verwachte trend.</p>
<p>Later heeft Cointegraph en hun team ook verduidelijkt en in detail uitgelegd waarom het verscheen en wat te doen in de toekomst. Geïnteresseerde studenten kunnen een kijkje nemen, maar we zullen ons niet op deze kwestie richten. Vandaag zullen we ons richten op of de markt eindigt, zelfs zonder goedkeuring van ETF.</p>
<p>Er was gisteravond geen dergelijk nieuws, en Bitcoin zal volgens de oorspronkelijke trend blijven stijgen, maar het zal alleen maar meer ondoorzichtig zijn. Eerder werd voorspeld dat de markttrend aan het einde van het jaar officieel zou beginnen, en dit proces zou wat langer duren. We kunnen geduldig wachten. Wat betreft waarom we dit zeggen, kunnen we naar de gegevens vanuit verschillende aspecten kijken:</p>
<p>1/ Het prijsverschil van GBTC wordt kleiner, ik weet niet of je oplet. Op het hoogtepunt was er een prijsverschil van -35+%. Met de kracht van Bitcoin dit jaar is het prijsverschil echter met -15,8% verkleind. Ik geloof dat het steeds meer schulden zullen worden totdat het positief wordt. Zolang het prijsverschil kleiner wordt en er zelfs ruimte is voor arbitrage, wordt aangenomen dat een groot bedrag opnieuw zal binnenkomen.</p>
<p>2/ Het saldo van de portemonnee van de beurs is consequent laag geweest, en het aantal mensen dat valuta opneemt en voor lange tijd vasthoudt, is toegenomen, wat wijst op een optimistische kijk op de toekomstige markt.</p>
<p>3/ Na twee jaar van een bear market heeft Bitcoin een sterke vraag naar herstel gehad. Hoewel het aan het einde van het jaar een golf heeft hersteld, is de kracht van Bitcoin verre van het verwachte niveau.</p>
<p>4/ Wereldwijde geopolitieke conflicten nemen toe en de financiële risico-aversie neemt toe. We hebben gezien dat goud op het punt staat om opnieuw de grens van $2.000 te doorbreken, en we geloven dat Bitcoin ook zal stijgen in de toekomst.</p>
<p>5/ Het belangrijkste is de cyclus. Aan het einde of begin van het jaar is er ook een periode van herstel, en er zijn ook verwachtingen voor spot ETF’s. Daarom vormt de markt een collectieve kracht en zal uiteindelijk een explosieve stijging laten zien.</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 enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>