RGFnZWxpamtzIG5pZXV3c3wgRGUgU0VDIGthbiB2w7PDs3IgMTAgamFudWFyaSBlZW4gc3BvdCBCaXRjb2luIEVURiBnb2Vka2V1cmVuOyBNaWNoYWVsIFNheWxvciBnZWxvb2Z0IGRhdCBCaXRjb2luIGVlbiBidWxsbWFya3QgemFsIGlubHVpZGVu

2023-12-20, 03:44

<p><img src="https://gimg2.gateimg.com/image/article/17030438651_14.png" alt=""></p>
<h2 id="h2-Crypto20Express20Spot20Bitcoin20ETF20kan20tegen201020januari20toestemming20krijgen20dit20zou20het20begin20kunnen20inluiden20van20een20bullish20fase20voor20Bitcoin816666"><a name="Crypto Express: Spot Bitcoin ETF kan tegen 10 januari toestemming krijgen; dit zou het begin kunnen inluiden van een bullish fase voor Bitcoin." class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Express: Spot <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ETF kan tegen 10 januari toestemming krijgen; dit zou het begin kunnen inluiden van een bullish fase voor Bitcoin.</h2><p>Op 20 december, volgens Cryptoslate, zei de oprichter van Galaxy Digital, Mike Novogratz, “Er wordt verwacht dat tegen 10 januari 2024, de SEC groen licht zal hebben gegeven voor een spot <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Tegen Bitcoin</a> ETF. Ik beschouw de datum als een deadline, aangezien het ook een sleutelmoment vertegenwoordigt in de rechtszaak van Gary Gensler tegen GrayScale. Als de goedkeuring vóór de datum wordt verkregen, zal de markt nog steeds verplicht zijn om nog eens zes maanden te wachten voordat het product verhandeld kan worden.</p>
<p>Leden van K33 Research hebben ook hun sterke geuit <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a> over de waarschijnlijkheid van goedkeuring ontvangen. In hun rapport van 18 december gaven Vetle Lunde, een senior analist, en Anders Helseth, de vice-president bij K33, aan dat recente wijzigingen in de ETF-aanvraag een grote kans op goedkeuring binnen de komende drie weken met zich meebrengen. Ze verwezen specifiek naar de timing als “vastgesteld”. De deadline van ‘10 januari’ werd voor het eerst onder de aandacht gebracht door Bloomberg’s ETF-analisten, Eric Balchunas en James Seyffart, die in oktober de kansen op 90% schatten voor een Bitcoin ETF op de aangegeven datum goedgekeurd te worden.</p>
<p>In een recente aflevering van de Unchained podcast suggereerde Bloomberg ETF-analist James Seyffart dat er mogelijk een verandering kan zijn in de positie van de SEC met betrekking tot <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>.</p>
<p>Seyffart wees erop dat de goedkeuring van een <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> futures ETF door de SEC kan worden geïnterpreteerd als een indirecte erkenning van Ethereum als een grondstof in plaats van een beveiliging. Hij benadrukte dat als Ethereum wordt geclassificeerd als een beveiliging, de implicaties significant zouden zijn, mogelijk resulterend in het schrappen van Ethereum futures en ETF’s. Seyffart suggereerde dat er een sterke mogelijkheid is dat Ethereum wordt gecategoriseerd als een grondstof en voorspelde dat dit zou kunnen gebeuren in 2024.</p>
<p>Bovendien benadrukte Seyffart dat SEC-voorzitter Gary Gensler heeft erkend dat Bitcoin een grondstof is, maar opmerkelijk minder vocaal is geweest over Ethereum, wat mogelijk indirect zijn neiging aangeeft om het niet als een effect te beschouwen. Seyffart stelde voor dat de SEC zich misschien zal onthouden van langdurige discussies over de classificatie van Ethereum.</p>
<p>Eerder, in een interview met Bloomberg TV, uitte Michael Saylor, mede-oprichter van MicroStrategy, zijn overtuiging dat Bitcoin in 2024 klaar staat om een bullmarkt te betreden. Hij suggereerde ook dat de mogelijke goedkeuring van een spot Bitcoin ETF het meest significante evenement op Wall Street in drie decennia zou kunnen vertegenwoordigen.</p>
<p>Bovendien merkte Michael Saylor op dat ondanks de mogelijke Amerikaanse goedkeuring van een Bitcoin spot ETF, zijn bedrijf een aantrekkelijke keuze zou blijven voor beleggers die op zoek zijn naar blootstelling aan Bitcoin. Hij wees erop dat hoewel ETF’s geen hefboomwerking hebben en kosten met zich meebrengen, zijn bedrijf hefboomwerking biedt zonder enige kosten in rekening te brengen. Saylor benadrukte dat ze geavanceerde instrumenten aanbieden die zijn ontworpen voor langetermijnbeleggers in Bitcoin.</p>
<p>In een recente blogpost beweerde Brian Armstrong, de CEO en medeoprichter van Coinbase, dat niet alleen cryptocurrencies hier zijn om te blijven, maar dat ze ook de toekomst van financiën vertegenwoordigen. Na aanzienlijke marktconsolidaties is de waarde van cryptocurrencies dit jaar met 90% gestegen, waarbij de handelsvolumes in het afgelopen kwartaal met 60% zijn gestegen. Wereldwijd zijn er nu ongeveer 425 miljoen individuen die cryptocurrency bezitten, en 83% van de G20-landen, samen met andere belangrijke financiële centra, hebben regelgeving geïmplementeerd of zijn momenteel bezig met het formuleren van regels om duidelijkheid en stabiliteit te bieden aan de crypto-sector.</p>
<p>In 2022 bereikte het volume van stablecoin-transacties op de blockchain bijna $9 biljoen, wat hoger is dan de gezamenlijke overdrachtsvolumes van Mastercard, American Express en Discover. Belangrijke internationale financiële knooppunten, waaronder Londen, Zwitserland, Hong Kong en Singapore, herscheppen zichzelf als centra voor cryptocurrency en nemen een meer open en globaal kader aan met als doel het aantrekken van werkgelegenheid en expertise die gepaard gaan met zo’n geavanceerd ecosysteem. Wereldwijd accepteren nu meer dan 100.000 handelaren en betalingsgateways cryptocurrencies, waarvan grote spelers zoals PayPal en Visa erbij horen. De toenemende omarming van cryptocurrency wordt gedreven door voordelen zoals lagere kosten, snellere transactietijden en het potentieel om nieuwe klanten aan te trekken.</p>
<p>Met betrekking tot statistieken geeft informatie van The Block aan dat de openstaande interesse voor Bitcoin-opties op de Chicago Mercantile Exchange (CME) een all-time piek heeft bereikt en bijna $2 miljard nadert. Een stijging in openstaande interesse duidt op verbeterde liquiditeit en een groeiende groep investeerders op de markt. Gegevens van Coinglass tonen aan dat binnen de openstaande interesse voor opties die op het einde van december aflopen, calls 65% uitmaken, terwijl puts goed zijn voor 35%. Een overwicht van call-opties boven puts suggereert doorgaans de mogelijkheid van een opwaartse markttrend.</p>
<h2 id="h2-Belangrijkste20Token20Trends20van20vandaag420714"><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-BTC427265"><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/1703063706image2.png" alt=""><br>Samenvatting: Het vieruurschema raakte het ondersteuningsniveau van $40.280 en veerde terug. Op korte termijn vormt zich een W-vormige bodem om door de weerstand te breken. Let op de convergentie van de middellangetermijnstructuur en overweeg long- en shortposities op basis van het algehele opwaartse kanaal. Weerstandsniveaus: $45.345 en $47.990; Ondersteuningsniveaus: $40.280 en $38.399.</p>
<h3 id="h3-ETH57389"><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/1703063725image3.png" alt=""><br>Samenvatting: Deze week blijft Ethereum schommelen boven de $2.135. Het heeft de $2.135 ondersteuning drie keer getest, en het korte-termijnadvies is om boven dit niveau te houden. De volgende ondersteuningsniveaus zijn $2.037 en $1.974. Let op een doorbraak van de $2.381 weerstand, met middellange termijn aandacht voor de neerwaartse trend aangegeven door de oranje lijn.</p>
<h3 id="h3-GT452487"><a name="GT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>GT</h3><p><img src="https://gimg2.gateimg.com/image/article/17030637581e493997-b1e0-46c8-a294-f64d49162291.png" alt=""><br>Samenvatting: De wekelijkse grafiek geeft het begin van de tweede fase van de bullmarkt aan. De wekelijkse trend is duidelijk gestabiliseerd, met kortetermijnsteun op de witte lijn en langetermijnconvergentie rond de $2,88. Verwacht vroege signalen die de altcoin-sector leiden, met targetprijzen van $12,877, $18,977, $28,58 en $44,99. Langetermijnbelegging wordt aanbevolen.</p>
<p>Macro: Amerikaanse aandelen stegen negen opeenvolgende dagen; de twee belangrijkste FOMC-stemgerechtigde leden uitten hun standpunt over renteverlagingen<br>Dinsdag, voorafgaand aan de opening van de Amerikaanse markt, daalde de Amerikaanse dollar index scherp, op een gegeven moment bijna het niveau van 102 bereikend, en eindigde uiteindelijk de sessie met een daling van 0,38%, op 102,11. Opbrengsten op Amerikaanse schatkistpapier daalden lichtjes, waarbij het rendement op de benchmark 10-jarige obligatie een dagelijkse laagte van 3,894% bereikte voordat het enigszins herstelde om te sluiten op 3,931%; ondertussen vestigde het rendement op de tweejarige obligatie, die meer beïnvloed wordt door het rentebeleid van de Federal Reserve, zich op 4,441%.</p>
<p>Met de daling van zowel de Amerikaanse dollar index als de Treasury rendementen, steeg de prijs van spot goud in de Amerikaanse handelssessie en doorbrak de $2.030 en $2.040 markeringen. Het edelmetaal bereikte op een gegeven moment een piek van $2.047,01 gedurende de dag voordat het sloot met een stijging van 0,65% op $2.040,31 per ounce. Spot zilver steeg ook en overschreed de $24 markering, en sloot met een winst van 1,05% op $24,05 per ounce. Op de Amerikaanse aandelenmarkt eindigden de drie belangrijkste indexen allemaal positief, waarbij de Dow Jones Industrial Average steeg met 0,68%, de S&amp;P 500 Index met 0,59% steeg, en de Nasdaq Composite Index met 0,66% steeg, wat een voortdurende stijging markeert gedurende negen handelssessies.</p>
<p>Spanningen in de Rode Zee, die de angst van handelaren aanwakkeren, hebben geleid tot een stijging van de internationale olieprijzen, die op een gegeven moment met 2% toenamen. WTI-ruwe olie bereikte een dagelijkse hoogte van $74,40 voordat hij eindigde met een winst van 1,81%, op $74,13 per vat; evenzo naderde Brent ruwe olie de drempel van $80 tijdens de handelsdag en sloot uiteindelijk met een stijging van 1,73% op $79,30 per vat.</p>
<p>Op dinsdag uitten de twee belangrijkste FOMC-stemgerechtigden van volgend jaar hun visie op inflatie en renteverlagingen.</p>
<p>Richmond Federal Reserve President Barkin verklaarde dat de Federal Reserve bereid is de rentetarieven te verlagen als de inflatie afneemt. Hij merkte echter ook op dat ze actief op zoek zijn naar tekenen die bevestigen dat de inflatie op koers ligt om terug te keren naar het doel van de Fed van 2%. “Als het lijkt dat de inflatie zal afnemen zoals verwacht, dan zullen we natuurlijk dienovereenkomstig handelen”, aldus Barkin op dinsdag.</p>
<p>Het moet worden benadrukt dat Barkin volgend jaar zal toetreden tot het stemmingscomité van het Federal Open Market Committee (FOMC). “Vanuit mijn perspectief geloof ik dat inflatie hardnekkiger is dan wat de gemiddelde persoon verwacht. Ik hoop dat ik het mis heb”, merkte hij op.</p>
<p>De president van de Atlanta Federal Reserve, Bostic, die volgend jaar een stemgerechtigd lid van de FOMC zal worden, verwacht dat er minder directe behoefte is aan renteverlagingen. Hij benadrukte dat de Federal Reserve een standvastige en geduldige aanpak moet hanteren bij het overwegen van toekomstige beleidsbeslissingen. ‘Naar mijn mening verwacht ik dat de inflatie de komende zes maanden vrij geleidelijk zal afnemen, wat aangeeft dat er geen behoefte is om snel onze strakke beleidspositie op te geven,’ verklaarde hij.<br>Bostic merkte op dat hij verwacht dat de Federal Reserve in de tweede helft van 2024 twee renteverlagingen zal doorvoeren als reactie op een geleidelijke daling van de inflatie. Hij verduidelijkte echter dat ‘er nog geen actieve discussies over zijn’.</p>
<p>Tijdens hun vergadering op 13 december hebben beleidsmakers besloten om de rentetarieven voor de derde keer op rij op het huidige niveau te handhaven en aangegeven dat ze verwachten dat er drie renteverlagingen zullen plaatsvinden in het volgende jaar. Desalniettemin voorspellen marktdeelnemers dat de eerste renteverlaging van de Federal Reserve al zo vroeg als maart volgend jaar zal plaatsvinden, ook al hebben verschillende functionarissen van de Federal Reserve geprobeerd de verwachtingen voor een aanzienlijke renteverlaging in het begin van 2024 te temperen.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Byron B.</strong><br>  <div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>