RGFnZWxpamtzIG5pZXV3cyB8IFVCUyB6YWwgY29tcGxpYW50IENyeXB0byBFVEYncyBvbmRlcnN0ZXVuZW47IEJUQy1oYW5kZWxza29zdGVuIHppam4gYmlqbmEgMTAwMCUgZ2VzdGVnZW47IENNRSB3b3JkdCBkZSBncm9vdHN0ZSBiZXVycyB2b29yIEJUQy1mdXR1cmVzIG9wZW4gaW50ZXJlc3Q=

2023-11-10, 06:11

<p><img src="https://gimg2.gateimg.com/image/article/16995968411_10.png" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20UBS20zal20compliant20crypto20ETFs20ondersteunen20Bitcoin20handelskosten20zijn20bijna20met20100020gestegen681486"><a name="Crypto Dagelijkse Samenvatting: UBS zal compliant crypto ETF’s ondersteunen; Bitcoin handelskosten zijn bijna met 1000% gestegen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: UBS zal compliant crypto ETF’s ondersteunen; <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> handelskosten zijn bijna met 1000% gestegen</h2><p>Volgens Bloomberg heeft UBS Group, samen met concurrenten zoals HSBC Holdings, Hongkongse klanten toegestaan om enkele Exchange Traded Funds te verhandelen die gekoppeld zijn aan cryptocurrencies, in het kader van de bevordering van de bouw van een digitaal activa centrum in Hong Kong.</p>
<p>Volgens ingewijden kunnen vermogende klanten vanaf vrijdag drie door de Hong Kong Securities Regulatory Commission goedgekeurde crypto ETF’s kopen op het UBS Hong Kong-platform, waaronder Samsung. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Futures Actief, CSOP Bitcoin Futures en CSOP Ether Futures ETF’s. Klanten kunnen ook toegang krijgen tot educatief materiaal om risico’s te begrijpen.</p>
<p>Toen CSOP Bitcoin Futures en CSOP Ether Futures werden gelanceerd in december vorig jaar, werden ze geprezen als de eerste Bitcoin en <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> futures ETF’s genoteerd in Azië. De totale activa van deze twee fondsen en Samsung’s investeringsvoertuigen zijn relatief klein, ongeveer $70 miljoen.</p>
<p>Sinds augustus zijn de transactiekosten voor Bitcoin bijna 1000% gestegen.</p>
<p>Gegevens tonen aan dat de gemiddelde transactiekosten voor de Bitcoin blockchain zijn gestegen naar $6,84, een stijging van ongeveer 970% van het dieptepunt van $0,64 dat in augustus werd bereikt. Het digitale vermogensbeheerbedrijf 21Shares wees er in een rapport op woensdag op dat deze stijging werd gedreven door een toename van het gietvolume van Ordinals, met bijna 1,9 miljoen inies die in de afgelopen twee weken naar de blockchain zijn geüpload.</p>
<p>Bovendien heeft Bitcoin volgens CryptoSlam-gegevens in de afgelopen 24 uur, na uitsluiting van schone transacties, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> overtroffen en is het de blockchain geworden met de hoogste NFT-verkopen.</p>
<p>In reactie hierop wezen analisten van 21Shares erop dat hoewel Ordinals momenteel alleen worden gebruikt voor sommige Meme coins, ze wel dienen als een proxy voor de toenemende vraag naar Bitcoin blockspace, wat met name belangrijk is voor miners. De opleving van Ordinals heeft ook bijgedragen aan de winstgevendheid van Bitcoin miners, waarbij blockchain transactiekosten momenteel ongeveer 8,5% van hun omzet uitmaken.</p>
<p>Volgens Deribit-gegevens verlopen BTC-optiecontracten met een nominale waarde van meer dan $1,179 miljard en ETH-optiecontracten met een nominale waarde van meer dan $400 miljoen voor levering op vrijdag (10 november). De maximale pijnsprijs voor BTC is $34.000; De maximale pijnsprijs voor ETH is $1.700.</p>
<p>Greeks.live verklaarde dat de afgelopen week belangrijke cryptocurrencies nieuwe hoogtepunten bereikten, waarbij BTC steeg naar $37.000, wat resulteerde in een aanzienlijke stijging van de volatiliteit op lange termijn. Op dit moment is BTC Dvol zo hoog als 65%, en ETH Dvol is ook zo hoog als 60%, waardoor beide op korte termijn nieuwe hoogtepunten creëren. De marktsentiment is hoog en de bullish sfeer is sterk.</p>
<p>Volgens Coinclass-gegevens heeft de Chicago Mercantile Exchange (CME) zijn uitstaande Bitcoin-futurescontracten verhoogd tot 111.080 BTC (ter waarde van $4,08 miljard), waarmee het Binance’s 104.100 BTC (ter waarde van $3,83 miljard) heeft overtroffen en de grootste beurs is met uitstaande Bitcoin-futurescontracten.</p>
<p>Met de versnelling van Bitcoin horizontale handel en Altcoin rotatie, blijft het bullish sentiment op de crypto-markt versterken.</p>
<p>In de afgelopen twee weken is Bitcoin in het bereik van $34.000 tot $36.000 gebleven. De twee weken durende consolidatie van Bitcoin heeft mensen ertoe aangezet om zich te richten op Altcoins, vooral <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> CME-handelaren hebben ook hun opwaartse risicoblootstelling blijven verhogen, en de open interest van CME blijft nieuwe hoogtepunten bereiken, met een bereik van 105.000 BTC ($3.7 miljard).</p>
<p>Ook de wekelijkse instroom van op futures gebaseerde ETF’s is aanzienlijk gestegen, waarbij ProShares’ BITO de op twee na grootste wekelijkse Bitcoin-instroom heeft gezien sinds november 2021.</p>
<p>Echter, JPMorgan Chase uitte twijfels over de duurzaamheid van de recente stijging op de cryptomarkt, waarbij werd gesteld dat “het herstel van cryptocurrencies enigszins overdreven lijkt.” Analisten van JPMorgan zeggen dat de twee belangrijkste factoren die lijken te hebben geleid tot de stijging van cryptocurrencies in de afgelopen maand, het vooruitzicht zijn van de goedkeuring van Bitcoin spot ETF’s in de Verenigde Staten en het falen van de SEC in de juridische zaken van Ripple en Grayscale.</p>
<p>Analisten zijn echter ‘sceptisch’ over deze factoren of argumenten. Ze zijn ‘voorzichtig met betrekking tot de toekomstige cryptomarkt’.</p>
<h2 id="h2-Belangrijkste20trends20in20tokens20van20vandaag205467"><a name="Belangrijkste trends in tokens van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijkste trends in tokens van vandaag</h2><h3 id="h3-BTC907351"><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/1699597090BTC.png" alt=""><br>BTC raakte gisteravond kort de belangrijke sleutel van $38.000 en voldeed aan het eerder voorgestelde doel van $37.800 in prijsstijging. Zoals verwacht vond er een significante prijsschommeling plaats, met een bereik van 6,2%, en deze is gestaag aan het terugtrekken. Op korte termijn wordt verwacht dat het stabiliteit behoudt boven het bereik van $35.300 en de algehele trend blijft bullish.</p>
<p>Een discussie over hoe significante prijsschommelingen te identificeren: Meestal, na een langdurige stijgende trend, als de korte termijn bodem divergentie te hoog is en de prijsbeweging te snel wordt, terwijl de futuresmarkt een tegenovergestelde toename van posities ziet, kan dit een voorbode zijn van een long-short confrontatie, zoals te zien is bij de snelle prijsdaling na het raken van het doel in dit g.</p>
<h3 id="h3-ETH204668"><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/1699597111ETH.png" alt=""><br>Vanwege het nieuws over iShares Ethereum Trust en zes andere instellingen die een ETF aanvragen, is het volume van de aankopen op de secundaire markt toegenomen. Op korte termijn is de prijs gestegen van $1.845 naar het weerstandsniveau van $2.135, waarbij de huidige prijs bijna het doel heeft bereikt.</p>
<p>De daggrafiek heeft geprobeerd om voor de derde keer het weerstandsniveau van $2.135 te doorbreken en bereikt een relatieve hoogte die in anderhalf jaar niet is gezien. Op korte termijn wordt aanbevolen om stabiliteit te handhaven op $2.037, en deze poging zal waarschijnlijk doorgaan naar $2.135 en richting $2.381 gaan. Er wordt ook verwacht dat dit de rotatie op de altcoin-markt zal leiden. De aanbeveling voor de limietorder is om stabiliteit te handhaven op $2.045.</p>
<h3 id="h3-RIO408083"><a name="RIO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>RIO</h3><p><img src="https://gimg2.gateimg.com/image/article/1699597129RIO.png" alt=""><br>De wereldwijde vermogensmarkt heeft de rally geleid. De langetermijnstrategie heeft aanzienlijke winsten gezien vanaf een dieptepunt van $0,1075 tot meer dan vier keer de huidige prijs. De fase-tops bevinden zich op $0,4650, $0,6060 en $0,9952, met langetermijndoeltoppen op $5,22 en $8,88.</p>
<h2 id="h2-Macro20Meerdere20functionarissen20van20de20Federal20Reserve20volgen20het20havikachtige20standpunt20van20Powell20Is20het20nog20steeds20te20vroeg20om20de20rente20te20verhogen824453"><a name="Macro: Meerdere functionarissen van de Federal Reserve volgen het havikachtige standpunt van Powell. Is het nog steeds te vroeg om de rente te verhogen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Meerdere functionarissen van de Federal Reserve volgen het havikachtige standpunt van Powell. Is het nog steeds te vroeg om de rente te verhogen?</h2><p>Op donderdag daalde de Amerikaanse dollarindex naar een laag niveau als gevolg van nieuwe tekenen van zwakte op de Amerikaanse arbeidsmarkt in de werkloosheidsgegevens. Vervolgens sprong het, gestimuleerd door de havikachtige opmerkingen van Powell, naar bijna het niveau van 106 en sloot uiteindelijk 0,36% hoger op 105,91.</p>
<p>De recente winsten van de drie belangrijkste Amerikaanse aandelenindices zijn ten einde gekomen door de havikachtige houding van Powell en de koude verkoop van Amerikaanse obligaties met een looptijd van 30 jaar. De Dow sloot 0,65% lager, de Nasdaq sloot 0,94% lager en de S&amp;P 500-index sloot 0,8% lager.</p>
<p>De veiling van 30-jaar Amerikaanse obligaties toonde een zwakke vraag en de Amerikaanse obligatierendementen hervatten hun opwaartse trend. Het rendement op 30-jaar Amerikaanse obligaties sloot op 4,772%, terwijl het rendement op 10-jaar Amerikaanse obligaties sloot op 4,628%; Het rendement op Amerikaanse staatsobligaties met een looptijd van twee jaar, dat gevoeliger is voor het rentebeleid van de Federal Reserve, herstelde met 5% tot 5,029%.</p>
<p>Spot goud beëindigde zijn drievoudige daling van drie dagen, weg van zijn bijna drie weken laag en brak kort de $1.960 grens. Uiteindelijk sloot het met een stijging van 0,45% op $1.958,6 per ounce; Spot zilver steeg met 0,48% en sloot op $22,64 per ounce.</p>
<p>Internationale olieprijzen schommelden horizontaal. WTI-ruwe olie sloot bijna vlak af op $75,54 per vat, en het prijsverschil van de spotprijs van WTI-ruwe olie is voor het eerst sinds juli verschoven naar een futures-premie; Brent-ruwe olie brak kortstondig door de 81-markering in de handelssessie, veegde vervolgens het grootste deel van de dagwinst weg en eindigde 0,23% hoger op $79,87 per vat.</p>
<p>Federal Reserve-voorzitter Powell hield een toespraak waarin hij verklaarde dat, indien nodig, de Federal Reserve niet zal aarzelen om het monetaire beleid verder aan te scherpen. Na de toespraak van Powell stelden handelaren in kortlopende rentefutures in de Verenigde Staten hun verwachting van de eerste renteverlaging van de Federal Reserve uit van mei volgend jaar naar juni.</p>
<p>Waarnemend voorzitter van de St. Louis Federal Reserve O’Neill Pace zei: “Het is nog te vroeg om de mogelijkheid van verdere renteverhogingen door de Federal Reserve op dit moment uit te sluiten.”</p>
<p>Richmond Federal Reserve-voorzitter Barkin zei: “Ik denk niet dat we de renteverhoging al hebben afgerond; De druk van inflatie in de dienstensector is nog steeds aan de gang.” Federal Reserve-gouverneur Bowman herhaalde zijn verwachting dat verdere renteverhogingen nodig zullen zijn.</p>
<p>Voorzitter Bostick van de Atlanta Fed verklaarde dat het beleid mogelijk al restrictief genoeg is. De Federal Reserve zal een verkrappingsstandpunt handhaven totdat het inflatiepercentage daalt tot 2%.</p>
<p>Voorzitter Gullsby van de Chicago Fed verklaarde dat de Fed waakzaam moet zijn voor het risico van rente-overschrijdingen. Het is nog te vroeg om te bespreken of en wanneer de focus moet worden verlegd naar renteverlagingen.</p>
<p>De renteverhogingen van de functionarissen hebben opnieuw bezorgdheid in de markt doen rijzen, maar de cryptomarkt is niet beïnvloed. Momenteel is het een onafhankelijke markttrend, wat ook onze eerdere voorspelling is van een marktuitbraak tegen het einde van het jaar. We zouden niet beïnvloed moeten worden door macro-economisch beleid, tenminste voor de komende drie maanden.</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 enkele beleggingssuggestie.<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 zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>