RGFnZWxpamtzIG5pZXV3cyB8IEdCVEMgU3VycGFzc2VzIE5WSURJQSwgd2l0aCBBIEdyb3d0aCBSYXRlIG9mIDIyMCUgVGhpcyBZZWFyOyBFdGhlcmV1bSBEZW5jaHVuIFVwZ3JhZGUgTWF5IEJlIFBvc3Rwb25lZCBVbnRpbCBOZXh0IFllYXI=

2023-10-27, 04:46

<p><img src="https://gimg2.gateimg.com/image/article/16983855961027.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20GBTC20heeft20NVIDIA20overtroffen20met20een20groeipercentage20van2022020dit20jaar20De20Ethereum20Denchun20upgrade20kan20worden20uitgesteld20tot20volgend20jaar266941"><a name="Crypto Dagelijkse Samenvatting: GBTC heeft NVIDIA overtroffen, met een groeipercentage van 220% dit jaar; De Ethereum Denchun upgrade kan worden uitgesteld tot volgend jaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: GBTC heeft NVIDIA overtroffen, met een groeipercentage van 220% dit jaar; De <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> Denchun upgrade kan worden uitgesteld tot volgend jaar</h2><p>Volgens TradeView-gegevens is de aandelenkoers van GBTC dit jaar met 220% gestegen tot $26,79.</p>
<p>Ondertussen is NVDA, het best presterende aandeel in de S&amp;P 500 index, gestegen met 198%, terwijl de S&amp;P 500 index met 9% is gestegen. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> is dit jaar verdubbeld tot $35000. Bovendien is, vanwege het optimistische sentiment, de negatieve premiesnelheid van GBTC gedaald van 46% naar 13%, wat wijst op een bullish markt.</p>
<p>JPMorgan Chase verklaarde in een onderzoeksrapport op woensdag dat <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over de goedkeuring door de Amerikaanse SEC van spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF’s blijft groeien. Het rapport stelt dat dit optimisme wordt weerspiegeld in de sterke prestaties van Bitcoin ten opzichte van andere digitale activa, en wijst erop dat Bitcoin onlangs een nieuw hoogtepunt voor het jaar heeft bereikt. Analisten onder leiding van Nikolaos Panigrtzoglou schreven: “Het lijkt erop dat de recente golf van kapitaalstromen institutionele betrokkenheid heeft.”</p>
<p>Analisten zeiden: “Onze futures-positie-proxy op basis van CME Bitcoin-futures (vaak voornamelijk gebruikt door institutionele beleggers) is de afgelopen week omhooggeschoten, niet alleen tot een jaarlijks hoogtepunt, maar ook tot niveaus vóór de FTX-crash in augustus 2022.” Ondertussen is de equivalente futures-positie-proxy voor CME <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Futures blijft traag.</p>
<p>Het rapport stelt dat de deelname van instellingen aan de recente opleving ook tot uiting komt in de verkeersanalyse in Bitcoin. Een grote hoeveelheid Bitcoin is naar grotere portemonnee-adressen gestroomd, wat wijst op de vraag van institutionele beleggers. Het rapport wijst erop dat dit in schril contrast staat met eerdere kwartalen, “toen Bitcoin instromen gedomineerd werden door kleinere portefeuilles en daardoor meer gedreven werden door particuliere beleggers.”</p>
<p>Op 26 oktober toont het nieuwste rapport van Matrixport aan dat de vijfde bullmarkt van Bitcoin officieel begon op 22 juni 2023 en Bitcoin voor het eerst in een jaar een nieuw hoogtepunt bereikte. Vanuit historisch perspectief is de gemiddelde opbrengst van Bitcoin +310% wanneer dit signaal wordt geactiveerd.</p>
<p>Op basis van dit signaal voorspelt Matrixport dat Bitcoin tegen december 2024 $125.000 kan bereiken. Het rapport wijst erop dat deze bullmarkt voornamelijk wordt gedreven door de verwachtingen van institutionele adoptie. De kenmerken van Bitcoin zijn traditioneel gerelateerd aan activa zoals goud en andere veilige haveninvesteringen zoals staatsobligaties, wat instellingen ertoe heeft aangezet om Bitcoin te overwegen om hun vermogensallocatie te diversifiëren. Het is geen to dat Bitcoin is gestegen toen de verhouding tussen de Amerikaanse staatsschuld en het bbp een onhoudbaar niveau had bereikt.</p>
<p>Op 27 oktober bevestigden Ethereum-clientontwikkelaars op donderdag dat de verwachte Denchun-upgrade niet zal worden geïmplementeerd in de hard fork van het netwerk vóór het einde van 2023. Anonieme Prysm-ontwikkelaar Potuz bevestigde tijdens de conference call van de kernontwikkelaar van vandaag dat het onmogelijk is om de mainnet in 2023 te fork out.</p>
<p>Hij wees erop dat er de afgelopen maanden consensusproblemen zijn geweest onder de 10 ontwikkelingsnetwerken die begonnen zijn met testen en upgraden, en “geen van hen is soepel verlopen.” Vorige maand, met de lancering van het Ethereum Holesky-testnetwerk later dan gepland, werd unaniem geloofd dat er weinig kans was om de Denchun-upgrade vóór december te voltooien.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag349398"><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-BTC20BTC757658"><a name="BTC (BTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC (BTC)</h3><p><img src="https://gimg2.gateimg.com/image/article/1698385627btc.png" alt=""><br>De hoogte van deze week op $36.000 heeft waarschijnlijk zijn hoogtepunt bereikt, wat duidt op een kortetermijn topfase. Wees voorzichtig met een mogelijke high-needle markt, wat betekent een snelle stijging naar $36.000 gevolgd door een snelle daling naar het niveau van $33.000. Op middellange termijn verwachten we nog steeds steun rond $37.700.</p>
<p>Na het bereiken van de piek wordt een fase van neergang verwacht, dus instappen tegen de huidige prijs wordt beschouwd als het najagen van de prijs, wat op korte termijn winst oplevert maar op lange termijn risico’s kan opleveren. Als u wacht op een tweede daling, blijf dan de ruimte rond $32.500 en $30.800 monitoren voor mogelijke retracement.</p>
<h3 id="h3-ETH747705"><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/1698385645Eth.png" alt=""><br>Het hoogtepunt van deze week bereikte het niveau van $1.857, een kritiek punt voor zowel bullish als bearish trends. Het is belangrijk op te merken dat er een bearish “M”-patroon is gevormd en het wordt aanbevolen om standvastig te blijven op $1.754. Een doorbraak van dit niveau zal waarschijnlijk leiden tot verdere dalingen richting $1.726 en $1.694. Over het algemeen suggereert het volume een bearish sentiment op de markt.</p>
<h3 id="h3-RACA380844"><a name="RACA" class="reference-link"></a><span class="header-link octicon octicon-link"></span>RACA</h3><p><img src="https://gimg2.gateimg.com/image/article/1698385662Raca.png" alt=""><br>De blockchain gaming sector is weer in opkomst, met voorgestelde posities op twee belangrijke niveaus: $0.00014, die mogelijk blijven stijgen naar $0.00017 en $0.000195. Er is nog steeds ruimte voor kortetermijnwinsten, en als je binnen dit bereik komt, wordt het aanbevolen om snel in te stappen en uit te stappen of een trailing stop-loss strategie te gebruiken om te mikken op $0.00029.</p>
<h2 id="h2-Macro20De20Fed20wordt20verwacht20de20rentetarieven20in20november20te20handhaven20en20verwacht20een20zachte20landing20voor20de20economie20te20realiseren851740"><a name="Macro: De Fed wordt verwacht de rentetarieven in november te handhaven en verwacht een zachte landing voor de economie te realiseren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De Fed wordt verwacht de rentetarieven in november te handhaven en verwacht een zachte landing voor de economie te realiseren</h2><p>Op 26 oktober groeide de Amerikaanse economie in het derde kwartaal op zijn snelste tempo in bijna twee jaar, doordat krappe arbeidsmarkten leidden tot loonsverhogingen, wat de consumentenbestedingen stimuleerde. De Amerikaanse economie heeft opnieuw de aanhoudende waarschuwing voor economische recessie sinds 2022 genegeerd. Volgens gegevens van het Amerikaanse Ministerie van Handel bedroeg het kwartaallijkse BBP-percentage in het derde kwartaal van de Verenigde Staten 4,9%, de snelste groeisnelheid sinds het vierde kwartaal van 2021.</p>
<p>Hoewel deze sterke economische groei waarschijnlijk niet zal aanhouden, bewijst het de veerkracht van de economie. Als gevolg van de UAW-staking en miljoenen Amerikanen die hun studieleningen hervatten, kan de groei in de Verenigde Staten in het vierde kwartaal vertragen. De meeste economen hebben hun voorspellingen herzien en geloven dat de Federal Reserve een ‘zachte landing’ voor de economie kan bereiken. Financiële markten verwachten dat de Federal Reserve de rentetarieven in november ongewijzigd zal houden.</p>
<p>De spotgoud steeg eerst en daalde vervolgens, bereikte een intraday hoogtepunt van $1.993,52 tijdens de Europese handelssessie, maar daalde vervolgens lichtjes, en sloot uiteindelijk 0,26% hoger op $1.984,74 per ounce; spotzilver slaagde er niet in om boven $23 te stabiliseren en sloot uiteindelijk 0,3% lager op $22,79 per ounce.</p>
<p>De drie belangrijkste Amerikaanse aandelenindices bleven dalen als gevolg van de weerstand van grote technologieaandelen, waarbij de Dow 0,76% lager sloot, de Nasdaq 1,76% lager sloot en de S&amp;P 500 index 1,18% lager sloot.</p>
<p>Iran heeft aangekondigd dat het in de nabije toekomst militaire oefeningen zal houden. De minister van Buitenlandse Zaken van Iran zei dat ze niet willen dat het conflict escaleert. Hamas is klaar om burgergevangenen vrij te laten en roept Israël op om 6.000 Palestijnen vrij te laten. Israël heeft verklaard dat het zal doorgaan met beperkte grondaanvallen op de Gazastrook. De Verenigde Staten sturen nog eens 900 soldaten naar het Midden-Oosten.</p>
<p>Er is niet veel informatie op macro niveau en het Israëlisch-Palestijnse conflict blijft escaleren. Gisteren zijn grondtroepen van Kishleb ‘s nachts het Gaza-gebied binnengegaan om enkele infrastructuur te raiden en meteen teruggetrokken uit het Gaza-gebied. Het Israëlische ministerie van Defensie zei dat dit was om zich voor te bereiden op toekomstige grondgevechten.</p>
<p>Intussen hebben negen Arabische landen, waaronder de Verenigde Arabische Emiraten, Jordanië, Bahrein, Saoedi-Arabië, Oman, Qatar, Koeweit, Egypte en Marokko, gezamenlijk een verklaring uitgegeven waarin ze Israël’s doden van burgers in de Gazastrook veroordelen en stellen dat “zelfverdediging geen reden kan zijn om internationaal recht te schenden en opzettelijk de legitieme rechten van het Palestijnse volk te negeren.” Ze beschuldigen Israël ook van het uitvoeren van “collectieve strafmaatregelen” tegen de Palestijnen, met als gevolg de verdrijving van Palestijnen.</p>
<p>Naarmate geopolitieke conflicten toenamen, steeg goud kortstondig tot 2000 punten. Onlangs hebben activa zoals veilige haven goud en Bitcoin de schommelingen van Amerikaanse aandelen niet gevolgd. Daarom moeten activa met veilige haven kenmerken voor investeerders relatief hoogwaardige doelen zijn voor de lange termijn.</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 opvattingen van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het herposten van het artikel is toegestaan, mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>