RGFnZWxpamtzIG5pZXV3cyB8IEhldCBBbWVyaWthYW5zZSBNaWRkZW4tT29zdGVuYmVsZWlkIGthbiBlZW4gbmlldXdlIGJ1bGxtYXJrdCB2ZXJvb3J6YWtlbjsgRGUgdm9vcnJhYWQgRXRoZXJldW0gQ0VYIGlzIGdlZGFhbGQgbmFhciBoZXQgbGFhZ3N0ZSBuaXZlYXUgaW4gZGUgZ2VzY2hpZWRlbmlzOyBBcmJpdHJ1bSBrYW4gbW9yZ2V

2023-10-26, 04:56

<p><img src="https://gimg2.gateimg.com/image/article/16983012661026.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Arthur20Hayes20gelooft20dat20de20Amerikaanse20MiddenOostenbeleid20kan20leiden20tot20een20nieuwe20bull20markt20Arbitrum20zal20een20belangrijke20aankondiging20doen50243"><a name="Crypto Daily Digest: Arthur Hayes gelooft dat de Amerikaanse Midden-Oostenbeleid kan leiden tot een nieuwe bull markt; Arbitrum zal een belangrijke aankondiging doen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Arthur Hayes gelooft dat de Amerikaanse Midden-Oostenbeleid kan leiden tot een nieuwe bull markt; Arbitrum zal een belangrijke aankondiging doen</h2><p>Arthur Hayes verklaarde in zijn blog dat de beleidskeuzes van de VS in de Oekraïnecrisis en het Israëlisch-Palestijnse conflict de spanningen verder kunnen doen escaleren, wat kan leiden tot een enorme stijging van de militaire uitgaven van de VS, wat op zijn beurt de inflatieverwachtingen en de rendementen op schatkistpapier zal doen stijgen. In deze omgeving zullen investeerders hun houdingen in Amerikaanse obligaties verminderen en in plaats daarvan hun houdingen in goud en <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> als veilige haven activa. Hayes gelooft dat dit kan leiden tot een nieuwe golf van crypto stierenmarkt.</p>
<p>Volgens een rapport van Galaxy Research, gebaseerd op de totale activa beheerd door de Amerikaanse vermogensbeheerindustrie, wordt de groeisnelheid van verschillende kanalen die <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s betreden in de industrie geclassificeerd en geschat. De conclusie is dat de instroom van geld in Bitcoin spot ETF’s naar verwachting in het eerste jaar $14 miljard zal bedragen, zal toenemen tot $27 miljard in het tweede jaar en zal toenemen tot $39 miljard in het derde jaar na lancering.</p>
<p>Het rapport vermeldt ook dat als de goedkeuring van Bitcoin spot ETF’s wordt vertraagd of afgewezen, de analyse zal veranderen vanwege tijd- en toegangsbeperkingen. Als alternatief, als de prijsprestatie slecht is of enige andere factor ervoor zorgt dat het gebruik of de adoptie van Bitcoin ETF’s lager is dan verwacht, kunnen hun schattingen te agressief zijn.</p>
<p>Aan de andere kant gelooft Galaxy dat de aannames over toegang, blootstelling en distributie conservatief zijn, dus de kapitaalinstroom kan ook hoger zijn dan verwacht. De instroom van fondsen van ETF’s, marktverhalen over de aankomende halvering van Bitcoin en de mogelijkheid dat de rentetarieven op korte termijn hun hoogtepunt bereiken, duiden er allemaal op dat 2024 een belangrijk jaar kan zijn voor Bitcoin.</p>
<p>Volgens CoinDesk heeft SEC-voorzitter Gary Gensler tijdens het Securities Enforcement Forum in Washington op woensdag geweigerd om plannen voor spot Bitcoin ETF’s uiteen te zetten. Hij verklaarde dat hij het ‘laat ontwikkelen’ en geen oordeel zal vellen totdat het SEC-personeel aanbevelingen doet aan het vijfkoppige comité. Gensler verzet zich wanneer hem wordt gevraagd om enige indicatie te geven van de tijd of volgorde die kan worden overwogen.</p>
<p>Gensler weigerde ook commentaar te geven op andere rechtszaken die zijn organisatie heeft aangespannen tegen cryptocurrency-bedrijven. Hij zei: “Ik zal elke crypto-transactiezaak zelf bepleiten, en deze argumenten zullen worden voorgelegd aan juristen.”</p>
<p>Gary Gensler woonde dit evenement bij om een toespraak te houden over handhaving van de SEC-wetgeving, die vol stond met kritiek op de cryptobranche, waarbij herhaald werd dat de branche “bezaaid is met niet-nalevend gedrag.” Gensler besprak dat hoewel cryptocurrencies relatief groot zijn in omvang, hun aandeel in de Amerikaanse kapitaalmarkt minder dan 1% is, dus dit onderwerp is overmatig geconsumeerd door de branche.</p>
<p>Op het gebied van gegevens is op 25 oktober volgens de Cryptocurrency Fear and Greed Index het marktsentiment teruggekeerd naar het hoogste niveau sinds de BTC-prijs in november 2021 $69.000 bereikte. De index staat momenteel op 72 van de 100 punten en bevindt zich in de ‘gulzige’ zone. De reden voor de kracht van de markt is dat het spot Bitcoin-handelsplatform van BlackRock (ETF) mogelijk geleidelijk goedkeuring zal krijgen van de Amerikaanse Securities and Exchange Commission.</p>
<p>Volgens CoinGecko-gegevens was 14 november 2021 de laatste keer dat de index 72 punten bereikte, slechts vier dagen nadat BTC op 10 november 2021 een historisch hoogtepunt van $69.044 bereikte.</p>
<p>CryptoCon, een crypto-analist, verklaarde in een artikel dat volgens de half cycle theorie BTC zijn mid cycle piek ($47,000) zal bereiken in juni 2024; Het hoogtepunt van de volgende cyclus zal verschijnen in december 2025, waarbij de prijzen naar verwachting zullen stijgen tot $90,000 tot $130,000.</p>
<p>Op 25 oktober plaatste het crypto-opties hulpmiddelplatform Greeks.live op sociale media dat het huidige marktsentiment snel afkoelt, met BTC Dvol die van een piek van bijna 70% gisteren naar de huidige 55% daalt, en er is bijna geen contante premie. Op dit moment is er vanuit het perspectief van futures- en optieposities onvoldoende opwaartse momentum. De maximale pijnpunten voor de belangrijkste termen van opties liggen allemaal onder de $31.000, terwijl het maandelijkse maximale pijn punt voor de aankomende afloop slechts $28.500 is.</p>
<p>Op 25 oktober koos Whale Address ervoor om ETH uit het handelsplatform over te dragen, volgens gegevens van on-chain data aggregator Santiment. Terwijl ETH-prijzen voor het eerst in bijna drie maanden de $1.850-grens doorbraken, is het aanbod van ETH in de wallet van het handelsplatform gedaald naar 8,41%, het laagste niveau sinds de oprichting van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">platform]. [Ethereum</a> in 2015. Het transactievolume van het waladres dat is onttrokken aan het gecentraliseerde handelsplatform voor ETH, heeft een hoogtepunt bereikt van zes maanden.</p>
<p>Bovendien vertegenwoordigt volgens de tweet van de Arbitrum Foundation ‘Morgen’ het emoji van de planeet. De tweet is bovenaan geplaatst, wat aangeeft dat morgen een belangrijke aankondiging zal worden gedaan. Geïnteresseerde partijen kunnen blijven afstemmen.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20Vandaag116039"><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-BTC133050"><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/1698301302BTC.png" alt=""><br>Het hoogtepunt voor deze week wordt nog steeds verwacht rond $36.000, met een middellangetermijndoel tussen $37.755 en $40.505 als weerstandsniveaus. Dit wordt verwacht tegen het einde van dit jaar of begin Q1 volgend jaar en zal waarschijnlijk een fase van de top zijn.</p>
<p>Na het bereiken van dit hoogtepunt wordt een fase van terugtrekking verwacht, dus het invoeren van de huidige prijs wordt beschouwd als een achtervolgingsinvoer. Korte termijn winsten zijn mogelijk, maar er kan een risico zijn om op de middellange termijn vast te zitten. Als u wacht op een tweede terugtrekking, let dan op potentiële ondersteuningsniveaus op $33.000 en $30.800.</p>
<h3 id="h3-ETH393512"><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/1698301323ETH.png" alt=""><br>Het hoogtepunt voor deze week bereikte het niveau van $1.857, wat een kritisch niveau is voor zowel bullish als bearish scenario’s. Het volume heeft een neerwaartse trend doorbroken die al zeven maanden aan de gang was, maar als het niet stabiliseert rond $1.815, kan een bearish trend aanhouden. Let op of $1.754 standhoudt als ondersteuning of dat er een kortetermijn neerwaartse driehoekspatroon ontstaat.</p>
<h3 id="h3-DOGE146299"><a name="DOGE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DOGE</h3><p><img src="https://gimg2.gateimg.com/image/article/1698301340DOGE.png" alt=""><br>De algemene trend is al bijna 900 dagen dalende. Vanaf het instappunt van $0.05925 halverwege de maand is er een stijging van 18,25% geweest in de prijs. Er zijn tekenen van een mogelijke piek op korte termijn. Als het opwaartse momentum aanhoudt, let dan op $0.08861 en $0.10799 als mogelijke doelen, die een stijging in de MEME-sector kunnen veroorzaken.</p>
<h2 id="h2-Macro20Grote20bedrijven20hebben20slechte20financile20verslagen20Amerikaanse20aandelen20sloten20gezamenlijk20lager20geopolitieke20factoren20zullen20blijven20van20invloed20zijn20op20het20beleid20van20centrale20banken899319"><a name="Macro: Grote bedrijven hebben slechte financiële verslagen, Amerikaanse aandelen sloten gezamenlijk lager, geopolitieke factoren zullen blijven van invloed zijn op het beleid van centrale banken" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Grote bedrijven hebben slechte financiële verslagen, Amerikaanse aandelen sloten gezamenlijk lager, geopolitieke factoren zullen blijven van invloed zijn op het beleid van centrale banken</h2><p>De Amerikaanse dollarindex steeg boven de 106 en eindigde 0,27% hoger op 106,57. De Amerikaanse schatkistrendementen herstelden zich, waarbij het 10-jaars Amerikaanse schatkistrendement terugkeerde boven de 4,9% en uiteindelijk sloot op 4,961%. Het rendement van de Amerikaanse schatkistrekening met een looptijd van twee jaar daalde eerst en steeg vervolgens, uiteindelijk sluitend op 5,125%.</p>
<p>Spot goud fluctueerde omhoog, maar vanwege buitenlandse mediaberichten dat Israël zijn grondoffensief zal uitstellen, daalde goud op korte termijn naar een intraday laagtepunt van $1.963,25 op de Amerikaanse markt, maar veerde later op en keerde terug boven $1.970, uiteindelijk met een stijging van 0,44% op $1.979,66/ounce; Spot zilver sloot 0,23% lager op $22,86 per ounce.</p>
<p>De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk lager, waarbij de Dow Jones Industrial Average 0,32% lager sloot en de Nasdaq 2,43% lager sloot, wat de grootste dagelijkse daling sinds februari dit jaar markeerde. De S&amp;P 500-index sloot 1,43% lager. Nvidia sloot meer dan 4% lager, de A-lijst van Google sloot 9,5% lager en de A-lijst van Microsoft sloot 3% hoger.</p>
<p>De financiële rapporten van grote technologieaandelen waren slecht en technologieaandelen werden de meest verkochte aandelen. Het moederbedrijf van Google, Alphabet, daalde bijna 10% nadat het vorige financiële rapport teleurstellende groei in zijn cloud business liet zien. De marktwaarde van het bedrijf is met meer dan $166 miljard gekrompen, wat de grootste dagelijkse daling uit de geschiedenis markeert. Ook de aandelenprijzen van Amazon en Nvidia daalden, achterblijvend bij de bredere markt, met aanzienlijke dalingen bij het financiële technologiebedrijf Affirm en het betalingsbedrijf Block.</p>
<p>Overzicht van de situatie tussen Palestina en Israël:</p>
<p>Het conflict tussen Palestina en Israël heeft geleid tot meer dan 8000 doden aan beide zijden. The Wall Street Journal meldde dat Israël heeft ingestemd met het uitstellen van zijn grondaanval op Gaza om de toevoeging van Amerikaanse luchtverdedigingsen in het Midden-Oosten mogelijk te maken. De premier van Israël verklaarde dat hij actief bezig is met de voorbereidingen voor een grondaanval en dat het tijdstip zal worden overeengekomen met het kabinet.</p>
<p>Er zijn meerdere schermutselingen geweest aan de tijdelijke grens tussen Libanon en Israël, en Biden verklaarde dat hij vast zal houden aan zijn standpunt over de ‘twee-landenoplossing’ om het Israëlisch-Palestijns conflict op te lossen.</p>
<p>President Erdogan van Türkiye heeft tot nu toe de sterkste opmerkingen gemaakt over het conflict tussen Israël en Hamas, waarbij hij beweert dat Hamas geen terroristische organisatie is, maar een “bevrijder” die vecht om het Palestijnse land en volk te beschermen. De aandelenindex van Türkiye daalde woensdag met 7,1%, de grootste daling sinds februari. De index activeerde die dag twee keer het circuit breaker-mechanisme.</p>
<p>In dit verband zei Elijah Oliveros-Rosen, hoofdeconoom opkomende markten van S&amp;P Global Ratings, dat wanneer je begint na te denken over welke landen mogelijk kwetsbaarder zijn voor de impact van stijgende energieprijzen, je je moet gaan richten op netto-energie-importeurs, zoals Chili, Türkiye en verschillende Aziatische economieën, zoals Thailand, de Filipijnen en India.</p>
<p>Als u de volgorde van inflatietransmissie in de afgelopen jaren bekijkt, toen het conflict tussen Rusland en Oekraïne uitbrak, vond de eerste prijsstijging plaats in de voedsel- en brandstofsectoren en liep vervolgens over naar het kerninflatiegebied. Grunwald zei: ‘voor landen die geen goed verankerde inflatieverwachtingen hebben, kan een nieuwe ronde van stijgende energieprijzen zich verspreiden, en we kunnen gedeeltelijk de situatie herhalen die we de afgelopen jaren hebben meegemaakt.’</p>
<p>De ‘ideale centrale bank’ heeft de markt ervan overtuigd dat zij de inflatieverwachtingen op middellange termijn koste wat het kost zal verankeren, zodat zij de tijdelijke stijging van de energieprijzen vrij soepel kunnen doorstaan. Echter, die centrale banken die dit nog niet hebben bereikt, lopen het risico opnieuw verdere verkrappingsmaatregelen te moeten nemen.</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 mening van de onderzoeker en vormt geen investeringsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan het artikel opnieuw te publiceren op voorwaarde dat 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>