RGFnZWxpamtzIG5pZXV3cyB8IE1ldCBoZXQgc2x1aXRlbiB2YW4gaGV0IEVURi1hYW52cmFhZ3ZlbnN0ZXIgaGVlZnQgZGUgaW5zdHJvb20gdmFuIEJpdGNvaW4gRVRQLWZvbmRzZW4gZWVuIGhpc3RvcmlzY2ggaG9vZ3RlcHVudCBiZXJlaWt0LCBCVEMga2FuIHRlZ2VuIGhldCBlaW5kZSB2YW4gMjAyMyBzdGlqZ2VuIHRvdCAkNDUuMDA

2023-11-16, 05:06

<p><img src="https://gimg2.gateimg.com/image/article/17001155031_16.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20instroom20van20Bitcoin20ETP20fondsen20bereikte20een20historisch20hoogtepunt20Bitcoin20kan20stijgen20naar2045K20tegen20het20einde20van202023767267"><a name="Crypto Dagelijkse Samenvatting: De instroom van Bitcoin ETP fondsen bereikte een historisch hoogtepunt, Bitcoin kan stijgen naar $45K tegen het einde van 2023" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De instroom van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETP fondsen bereikte een historisch hoogtepunt, Bitcoin kan stijgen naar $45K tegen het einde van 2023</h2><p>Onlangs verklaarde Bloomberg-analist James Seyfart op het X-platform dat de Amerikaanse Securities and Exchange Commission (SEC) een beslissing zal nemen over de <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF’s ingediend door Hashdex en Franklin op 17 november en Global X op 21 november. James Seyfart gelooft dat de SEC waarschijnlijk de beslissing zal uitstellen.</p>
<p>Maar hij gelooft ook nog steeds dat er een kans van 90% is dat het 19b-4-document voor het beoordelen van Bitcoin spot ETF-aanvragen vóór 10 januari 2024 zal worden goedgekeurd.</p>
<p>Bovendien wordt begrepen dat Global X een herzien prospectus heeft ingediend voor een Bitcoin spot ETF.</p>
<p>Zoals eerder gemeld, heeft indexfondsreus Global X op 5 augustus volgens officiële documenten een aanvraag ingediend om spot Bitcoin ETF-producten op vrijdag te laten noteren en heeft Coinbase ook aangewezen als zijn partner voor het delen van monitoringprotocollen om goedkeuring van regelgeving te verkrijgen.</p>
<p>Op 15 november, volgens een K33 Research rapport, is de vraag naar Bitcoin via handelsplatform handelsproducten (ETP’s) door instellingen aanzienlijk toegenomen in de afgelopen maand, met een stijging van 27095 BTC, waarmee een recordniveau wordt bereikt en het verkeer in juni en juli overschrijdt nadat BlackRock Bitcoin spot ETF’s heeft ingediend.</p>
<p>Vetle Lunde, Senior Analist bij K33 Research, en Anders Helseth, Vice President, verklaarden dat naast de instroom van Bitcoin ETP, de aanhoudend grote blootstelling van CME met de naderende deadline voor de nieuwste Bitcoin spot ETF van de Amerikaanse Securities and Exchange Commission wijst op sterke vraag van instellingen in vergelijking met Bitcoin.</p>
<p>Analisten zeggen dat het smalle tijdsbestek voor het goedkeuren van alle huidige Bitcoin spot ETF-aanvragen zal eindigen op vrijdag 17 november. Deze deadline heeft specifiek betrekking op de aanvragen van Hashdex en Franklin. Als de SEC echter alle aanvragen tegelijkertijd wil goedkeuren, is dit venster een gelegenheid om de beslissing uit te voeren.</p>
<p>Nadat de vensterperiode is verstreken, zullen hoewel Global X ETF nog een deadline heeft (21 november), alle huidige aanvragen niet meer gelijktijdig worden goedgekeurd. In deze situatie kan het momentum van de crypto-markt vertragen omdat het mogelijk enkele weken kan duren om te wachten op belangrijk nieuws met betrekking tot ETF’s.</p>
<p>Matrixport tweette op het X-platform dat terwijl de markt veerkrachtig blijft, stieren nog steeds domineren en Bitcoin de verkoopstrend heeft weerstaan. Inflatiegegevens tonen aan dat de Amerikaanse CPI-index is gedaald tot 3,2%, wat aangeeft dat de Federal Reserve de rentetarieven kan verlagen. De Amerikaanse overheid heeft de operaties niet opgeschort, waardoor de ondersteuning van de overheid gegarandeerd is, en de hoop op goedkeuring van Bitcoin ETF’s nog steeds bestaat. De markt blijft bullish en de langetermijnverwachting van Matrixport om een doel van $45.000 te bereiken tegen het einde van het jaar blijft ongewijzigd.</p>
<p>Op 16 november plaatste Arthur Hayes op sociale media dat sinds begin november bijna $200 miljard aan liquiditeit in de markt is geïnjecteerd, omdat het saldo van reverse repurchase (RRP) aangehouden door de New York Fed is afgenomen, terwijl het saldo van de US Treasury General Account (TGA) onveranderd is gebleven. Risico-activa zoals Bitcoin en cryptovaluta zullen blijven stijgen.</p>
<p>Rostin Behnam, voorzitter van de Commodity Futures Trading Commission (CFTC) van de Verenigde Staten, verklaarde onlangs tijdens een bijeenkomst aan de Georgetown University dat er ‘niets is veranderd’ bijna een jaar na de ineenstorting van de crypto-uitwisseling FTX. Soortgelijke gebeurtenissen als bij FTX kunnen zich opnieuw voordoen. Hij verklaarde ook dat de cryptomarkt sinds de uitbraak van de COVID-19-pandemie ingrijpende veranderingen heeft ondergaan. Rostin Behnam is van mening dat het Congres een routekaart moet ontwikkelen en de CFTC regelgevende bevoegdheid moet verlenen over de cryptomarkt.</p>
<p>In december 2022 drong Behnam er bij de Senaatscommissie voor Bankwezen op aan om snel regulerende maatregelen te nemen om de grotere risico’s te voorkomen die cryptocurrencies kunnen vormen. Hij verklaarde destijds dat de CFTC niet over de macht beschikte om de digitale grondstoffenmarkt uitgebreid te reguleren. Om te voorkomen dat deze situatie zich opnieuw voordoet, moet de CFTC de juiste autorisatie verkrijgen van het Congres.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag275068"><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-BTC975638"><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/1700115538BTC 13.54.38.png" alt=""><br>Het dagelijkse diagram daalde terug naar het ondersteuningsniveau van $34,870 en veerde terug om gisteravond het sleutelniveau van $38,000 aan te raken, wat duidt op hoge volatiliteit op de huidige niveaus. Voor korte-termijn bullish posities is het raadzaam om te wachten op een doorbraak boven $40,495; als dit niet lukt, kan een tweede retracement het ondersteuningsniveau van $36,000 als doel hebben.</p>
<h3 id="h3-ETH181151"><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/1700115556ETH 13.54.38.png" alt=""><br>De daggrafiek daalde naar $1.951, gevolgd door een rebound die de weerstand op $2.065 testte. De korte termijn strategie suggereert stabiliteit rond $2.037 te handhaven, met een mogelijke uitverkoop voorafgaand aan een nieuwe stijging. Conservatieve longposities wordt geadviseerd te wachten op een doorbraak van $2.135, gericht op de top van $2.318.</p>
<h3 id="h3-FTT93816"><a name="FTT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FTT</h3><p><img src="https://gimg2.gateimg.com/image/article/1700115577FTT 13.54.38.png" alt=""><br>De algehele trend van FTT van $1,3965 naar $1,56 is gestegen tot een hoogtepunt van $5. Korte-termijn weerstand op $3,67, met een koersdoel van $4,92 voor bullish posities. Let op voor een mogelijke valse doorbraak en daaropvolgende neerwaartse trend na het niet kunnen doorbreken.</p>
<h2 id="h2-Macro20De20kans20dat20de20rente20niet20zal20worden20verhoogd20in20december20is2010020renteverlagingen20zullen20op20korte20termijn20niet20plaatsvinden429601"><a name="Macro: De kans dat de rente niet zal worden verhoogd in december is 100%, renteverlagingen zullen op korte termijn niet plaatsvinden." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: De kans dat de rente niet zal worden verhoogd in december is 100%, renteverlagingen zullen op korte termijn niet plaatsvinden.</h2><p>Op woensdag herstelde de Amerikaanse dollar index en hield het niveau van 104 vast, uiteindelijk met een stijging van 0,317% op 104,4. De opbrengst van de Amerikaanse staatsobligaties steeg tijdens de handelssessie. De 10-jarige Amerikaanse Treasury-opbrengst sloot op 4,543%; De opbrengst op de Amerikaanse Treasury van twee jaar, die gevoeliger is voor het beleidsrentetarief van de Federal Reserve, sloot op 4,916%. De drie belangrijkste Amerikaanse aandelenindices eindigden in een volatiele sessie, waarbij de Dow Jones Industrial Average met 0,47% steeg, de S&amp;P 500-index met 0,16% steeg en de Nasdaq met 0,07% steeg.</p>
<p>Spotgoud brak kortstondig het niveau van 1970 en bereikte een nieuwe weekhoogte, maar daalde vervolgens onder het niveau van 1960, waarbij alle winsten gedurende de dag werden teruggenomen en uiteindelijk met 0,04% werd gesloten op 1961,67 Amerikaanse dollars per ounce; Spotzilver steeg verder boven het niveau van 23 en sloot uiteindelijk 1,64% hoger op $23,44 per ounce.</p>
<p>Door de onverwachte stijging van de Amerikaanse voorraad ruwe olie zijn de internationale olieprijzen gedaald. WTI-ruwe olie miste twee opeenvolgende gehele niveaus van 78 en 77 en sloot uiteindelijk 2,09% lager op $76,53 per vat; Brent-ruwe olie sloot 1,75% lager op $80,95 per vat.</p>
<p>Volgens de ‘Federal Reserve Observation’ van CME is de waarschijnlijkheid dat de Federal Reserve de rentetarieven in december ongewijzigd houdt in het bereik van 5,25% -5,50% 100%, en de waarschijnlijkheid van een renteverhoging met 25 basispunten naar het bereik van 5,50% -5,75% is 0%. De waarschijnlijkheid dat de rentetarieven in januari volgend jaar ongewijzigd blijven, is 100%, en de waarschijnlijkheid van een cumulatieve renteverhoging van 25 basispunten is 0%.</p>
<p>Op woensdag waarschuwde de voorzitter van de San Francisco Fed, Daley, dat als de Fed te vroeg verklaart dat ze de inflatie onder controle heeft en vervolgens de rente weer moet verhogen, haar geloofwaardigheid in gevaar zal komen.</p>
<p>Daley verklaarde dat de Federal Reserve “zorgvuldig moet overwegen, geduldig moet wachten en geen overhaaste oordelen of verklaringen moet maken.” Ze zei: “We moeten moedig genoeg zijn om te zeggen ‘we weten het niet’ en moedig genoeg om te zeggen ‘we moeten de tijd nemen om het goed te doen.’”</p>
<p>Daley wordt volgend jaar stemgerechtigd lid van het Federal Open Market Committee (FOMC). Gevraagd naar het plan om de rente volgend jaar te verlagen, zei ze dat de focus van het debat niet langer zal liggen op het al dan niet versoepelen, maar op de kwestie van het “normaliseren” van de rentetarieven na een “zeer strenge” periode.</p>
<p>Op een gegeven moment willen we niet te streng zijn of heel streng. We willen het beleid aanpassen aan een meer normaal spoor omdat we geloven dat de economie zich naar normalisatie beweegt,” zei ze.</p>
<p>Bij het afwegen van het monetair beleid verklaarde Daley dat zij inflatieverwachtingen en daadwerkelijke economische prestaties in een jaar als meetcriteria zou gebruiken. Ze voegde eraan toe dat renteverlagingen ‘op korte termijn niet zullen plaatsvinden’.</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 beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten voor dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens auteursrechtinbreuk.<br></div><p></p><br></div></div></div></div>