RGFnZWxpamtzIG5pZXV3cyB8IERlIFNFQyBrYW4gb3BuaWV1dyBkZSBnb2Vka2V1cmluZyB2YW4gQml0Y29pbiBTcG90IEVURidzIHVpdHN0ZWxsZW4sIFp1aWQtS29yZWEgYmVnaW50IG1ldCBoZXQgcGxhbm5lbiB2YW4gY3J5cHRvLXJpY2h0bGlqbmVuLCBCbHVlIENoaXAgTkZULXZsb2VycHJpanplbiBoZXJzdGVsZGVuIHppY2g=

2023-11-15, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/17000286531_15.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijks20Overzicht20De20SEC20kan20opnieuw20de20goedkeuring20van20Bitcoin20spot20ETFs20uitstellen20Blue20chip20NFTmarkt20hersteld494096"><a name="Crypto Dagelijks Overzicht: De SEC kan opnieuw de goedkeuring van Bitcoin spot ETF’s uitstellen, Blue chip NFT-markt hersteld" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijks Overzicht: De SEC kan opnieuw de goedkeuring van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF’s uitstellen, Blue chip NFT-markt hersteld</h2><p>Bloomberg-analist James Seyfart tweette dat de deadline voor de Amerikaanse SEC om een beslissing te nemen over drie <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> De indiening van spot-ETF-aanvragen nadert en het is zeer waarschijnlijk dat we een vertraagde order van de SEC zullen zien. Maar dit zal onze visie dat de kans dat 19b-4 vóór 10 januari 2024 wordt goedgekeurd 90% is, niet veranderen. In antwoord op de vraag van Twittergebruikers over de mogelijkheid dat Bitcoin spot-ETF’s deze week worden goedgekeurd, verklaarde Seyfart dat de waarschijnlijkheid minder dan 50% is, maar groter dan 0.</p>
<p>Met betrekking tot de adoptie van Bitcoin ETF’s verklaarde Cathie Wood, CEO van ARK Invest, in een interview met CNBC dat gezien Gary Gensler, voorzitter van de Amerikaanse Securities and Exchange Commission (SEC), die zeer vertrouwd is met Bitcoin, het moeilijk is om met een redelijke reden tegen spot ETF’s te zijn.</p>
<p>Voordat hij voorzitter van de SEC werd, gaf hij cryptocurrency- en blockchaincursussen aan het Massachusetts Institute of Technology (MIT). Vervolgens noemde Cathie Wood ‘speculatie’ over Gensler’s verlangen om als Amerikaanse minister van Financiën te dienen, die ‘zeer bezorgd was over de Amerikaanse dollar’, wat suggereert dat de ambitie van Gary Gensler om minister van Financiën te worden misschien de werkelijke reden is voor de obstructie van spot Bitcoin ETF’s.</p>
<p>Wood voorspelde ook dat spot ETF’s uiteindelijk goedgekeurd zouden worden en verklaarde dat tegen 2030 de marktwaarde van cryptocurrencies zou toenemen van de huidige $1 biljoen naar $25 biljoen. Momenteel bekijkt de SEC 12 Bitcoin spot ETF-aanvragen, waaronder ARK Invest.</p>
<p>De raad van bestuur van Boya Interactive, een beursgenoteerd bedrijf aan de Hong Kong Stock Exchange, heeft een mededeling aan aandeelhouders uitgegeven waarin staat dat de aankoop en het bezit van cryptocurrency een belangrijke maatregel is voor de zakelijke lay-out en ontwikkeling van de groep in het Web3-veld, en een belangrijk onderdeel van de assetallocatiestrategie van de groep.</p>
<p>Na zorgvuldige overweging beveelt de raad van bestuur aan om voorafgaande goedkeuring van aandeelhouders te zoeken om de raad het recht te verlenen om potentiële crypto-aankopen te doen tijdens de autorisatieperiode, die een periode van 12 maanden is vanaf de datum van formele goedkeuring van de gewone resolutie over autorisatie en potentiële crypto-aankopen door de bijzondere vergadering van aandeelhouders, met een totaal aankoopbedrag van niet meer dan $100 miljoen.</p>
<p>Eerder in augustus kondigde het in Hong Kong genoteerde bedrijf Boya Interactive aan dat de raad van bestuur een budget van $5 miljoen (ongeveer HKD 39.098 miljoen) had goedgekeurd voor de aankoop van cryptocurrencies op gereguleerde en gelicentieerde handelsplatforms, voornamelijk Bitcoin (BTC) en. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> (ETH), om het toekomstige zakelijke kader van het bedrijf in het Web3-veld te stimuleren in het komende jaar.</p>
<p>Boya Interactive heeft ook onthuld dat deze financieringsbron kasreserves zijn die zijn gegenereerd door de activiteiten van de groep in Hong Kong en het buitenland. De aankoop van cryptocurrency zal worden uitgevoerd volgens marktomstandigheden en zal strikt voldoen aan het beleid van de relevante rechtsgebieden met betrekking tot cryptocurrency.</p>
<p>Op 14 november, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> heeft de officiële lancering aangekondigd van een mobiele applicatie voor Android-gebruikers. In de afgelopen maanden is <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> zorgvuldig aangepast aan Android om dezelfde uitwisselingservaring te bieden die miljoenen mensen hebben gehad op Uniswap. In de toekomst zullen er om de week updates worden uitgebracht om de uitwisselingssnelheid te versnellen en meer tokens en chains toe te voegen voor uitwisseling.</p>
<p>De Uniswap-toepassing werd voor het eerst gelanceerd op iOS in april en werd in minder dan een maand de top drie portemonnee voor nieuwe downloads.</p>
<p>Onlangs heeft de Zuid-Koreaanse Monetaire Autoriteit een Task Force opgericht over de notering van virtuele activa (TF) om de regelgevingsnormen (richtlijnen) te bespreken voor notering, handhaving van notering en schrapping. De task force omvat financiële autoriteiten, publieke en private sectoren en externe experts. Een persoon van de Financiële Toezichthoudende Autoriteit verklaarde dat “we van plan zijn om conclusies te trekken en enkele maanden voor de uitvoering van de Maximum Asset User Protection Act in juli volgend jaar aan het Congres te rapporteren,” en voegde eraan toe dat “we zullen bestuderen hoe we maatregelen kunnen nemen. Verbeter de effectiviteit van normen (onder toezicht van financiële autoriteiten) en zorg ervoor dat de sector zichzelf kan beschermen door middel van zelfregulering.</p>
<p>Volgens Blur-gegevens is de prijs van blue chip NFT-vloeren onlangs hersteld. Daarvan is de prijs van de BAYC-serie vloeren momenteel 30,37 ETH, met een wekelijkse stijging van 6,73%. De prijs van de MAYC-serie vloeren is momenteel 5,72 ETH, met een wekelijkse stijging van 5,43%. De prijs van de Azuki-serie vloeren is momenteel 6,06 ETH, met een wekelijkse stijging van 17,06%. De prijs van Doodles-vloeren is momenteel 2,21 ETH, met een wekelijkse stijging van 14,51%. Daarnaast wordt de BendDAO-token BEND van het NFT-uitleenprotocol momenteel genoteerd op $0,005476, een stijging van 29% in 24 uur.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag581186"><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-BTC393698"><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/1700028696BTC.png" alt=""><br>De dagelijkse grafiek is teruggekeerd naar de ondersteuning van $34.870 en vormt effectieve ondersteuning zoals eerder vermeld. Verdere ondersteuning is te vinden op $33.085 en $32.765. Deze week gaat verder met een trend van hoge retracement. De langetermijnstrategie suggereert voortzetting van de positionering op laag niveau, met voorzichtigheid tegen hoge volatiliteit.</p>
<h3 id="h3-ETH21883"><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/1700028720ETH.png" alt=""><br>De daggrafiek probeert een derde doorbraak te bereiken op $2.135, maar momentum ontbreekt. Retracement naar $1.951 is mogelijk als $2.000 geen ondersteuning biedt. De korte termijn structuur kan blijven retracing binnen het dalende bereik. Korte posities worden geadviseerd om aan te houden bij $1.951.</p>
<h3 id="h3-FTT266671"><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/1700028742FTT.png" alt=""><br>Sinds de algehele trend van $1,3965 tot $5 werden vanochtend een kortetermijnconvergentie en opwaartse beweging waargenomen. Het wordt aanbevolen om vast te houden aan de $3,67 weerstand. Bij het niet stabiliseren kan een valse doorbraak resulteren, waardoor de markt terugvalt naar het $3,21 dieptepunt. Korte termijn voorzichtigheid is geboden.</p>
<h2 id="h2-Macro20CPI20lager20dan20verwacht20renteverhogingscyclus20kan20ten20einde20zijn20gekomen865522"><a name="Macro: CPI lager dan verwacht, renteverhogingscyclus kan ten einde zijn gekomen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: CPI lager dan verwacht, renteverhogingscyclus kan ten einde zijn gekomen</h2><p>Op dinsdag versterkten zwakkere dan verwachte inflatiegegevens uit de Verenigde Staten de hoop dat de Federal Reserve de renteverhogingen had afgerond.</p>
<p>De Amerikaanse dollarindex bereikte tijdens de sessie niveaus van 104, wat de eerste keer was sinds 1 september, en sloot uiteindelijk 1,523% lager af op 104,07. Niet-Amerikaanse valuta’s vierden gezamenlijk, waarbij de euro boven de 1,08 tegen de Amerikaanse dollar steeg, een nieuw hoogtepunt sinds 4 september. Het pond bereikte een nieuw hoogtepunt van twee maanden van 1,25 tegen de Amerikaanse dollar. De Amerikaanse dollar daalde tijdens de dag met maar liefst 1% ten opzichte van de Japanse yen. De Nieuw-Zeelandse dollar bereikte voor het eerst sinds 6 november 0,60 tegen de Amerikaanse dollar, met een stijging van meer dan 2% op de dag. De Australische dollar stond op 0,65 tegen de Amerikaanse dollar, een nieuw hoogtepunt sinds 7 november, met een dagelijkse stijging van meer dan 2%.</p>
<p>De drie belangrijkste Amerikaanse aandelenindices sloten gezamenlijk hoger af, waarbij de Dow Jones-index met 1,43% steeg, de Nasdaq met 2,37% steeg en de S&amp;P 500-index met 1,9% steeg. Tesla (TSLA. O) steeg met 6%, NVDA. O (NVDA. O) steeg met 2% en Microsoft (MSFT. O) steeg bijna 1%, en bereikte een historisch hoogtepunt in marktwaarde.</p>
<p>Het rendement op Amerikaanse obligaties daalde over de hele linie, met een algemene daling van ongeveer 20 basispunten. Het rendement op Amerikaanse staatsobligaties met een looptijd van 10 jaar sloot op 4,453%; het rendement op Amerikaanse staatsobligaties met een looptijd van twee jaar, die gevoeliger is voor de rentetarieven van de Federal Reserve, daalde zelfs nog dieper en sloot op 4,836%.</p>
<p>Spot goud bleef stijgen na de publicatie van onverwacht afkoelende CPI-gegevens, bereikte het niveau van 1970 en sloot uiteindelijk 0,89% hoger op $1963,18 per ounce, waarmee het zijn beste dagelijkse prestatie sinds 27 oktober behaalde; Spot zilver herstelde zich tot 23 niveaus en sloot 3,51% hoger op $23,09 per ounce.</p>
<p>Internationale olieprijzen daalden lichtjes en sloten iets lager op de Amerikaanse markt vanwege het ontbreken van duidelijke tekenen van escalatie van spanningen in het Midden-Oosten en onzekerheid over de Amerikaanse olievoorraden. WTI-ruwe olie daalde met 0,41% tot $ 78,16 per vat; Brent-ruwe olie sloot 0,29% lager op $ 82,39 per vat.</p>
<p>De algemene en kern CPI van de Verenigde Staten waren allebei lager dan verwacht, met een ongereguleerd jaarlijks CPI-tarief van 3,2% in oktober en een maandelijks kern-CPI-tarief van 0,2%. De huidige cyclus van de prijsstelling van rentetermijncontracten door de Federal Reserve is volledig ten einde gekomen, en er wordt verwacht dat de rentetarieven tegen het einde van volgend jaar in totaal met 100 basispunten zullen worden verlaagd, waarbij de eerste ronde van renteverlagingen al in mei wordt verwacht.</p>
<p>De NFIB Small Business Confidence Index in de Verenigde Staten daalde in oktober met 0,1 procentpunt tot 90,7, het laagste punt in vijf maanden, voornamelijk als gevolg van de verslechtering van de winst als gevolg van zwakke verkopen en stijgende kosten. Bijna een derde van het netto-inkomen van kleine bedrijven is in de afgelopen drie maanden gedaald, het grootste aandeel in meer dan een jaar. Deze verslechtering geeft aan dat de consumentenvraag kan afnemen na een gestage groei in het derde kwartaal.</p>
<p>Voorzitter van de Chicago Fed, Goolsby: De vooruitgang van de inflatie is gaande, maar er is nog een weg te gaan. Nieuwsagentschap van de Federal Reserve: De cyclus van renteverhogingen kan ten einde zijn, met de nadruk op het herzien van de richtlijnen voor verklaringen in de toekomst. Vicevoorzitter van de Federal Reserve, Jefferson: De onzekerheid van de persistentie van de inflatie kan een krachtiger beleidsreactie vereisen dan in andere situaties.</p>
<p>De Fed is in de laatste fase van de strijd tegen inflatie, en de drempel voor verdere renteverhogingen en -verlagingen kan behoorlijk hoog zijn. Deze gegevenspublicatie zal de algemene situatie niet beïnvloeden, aangezien de Federal Reserve meerdere exemplaren van gegevens moet zien - daarom wordt verwacht dat de impact van deze gegevenspublicatie op de markt beperkt zal zijn. De focus van Wall Street ligt op de kern-CPI. Oorspronkelijk verwachtte de markt dat de daling min of meer stil zou staan, maar zowel de jaarlijkse als de maandelijkse percentages waren lager dan de marktverwachtingen. Vooral de maand-op-maand daling tot 0,2% komt overeen met het inflatiedoel van 2%.</p>
<p>De kern-CPI op jaarbasis blijft echter in oktober tweemaal de inflatiedoelstelling van de Federal Reserve. Maar de Federal Reserve zal zijn havikachtige voorkeur veranderen, tenzij de maandelijkse kern-CPI gedurende ten minste zes opeenvolgende maanden stabiel blijft op 0,2% -0,3%.</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 beleggingsadvies.<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 zal juridische actie worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>