RGFnZWxpamtzIG5pZXV3cyB8IFNFQyBrYW4gd29yZGVuIGdlZHdvbmdlbiBvbSBCVEMgU3BvdCBFVEYncyBnb2VkIHRlIGtldXJlbiwgVml0YWxpayBCdXRlcmluJ3MgdG9lc3ByYWFrIGR1d2RlIFJBSSBtZXQgbWVlciBkYW4gODAlIG9taG9vZywgaW52ZXN0ZWVyZGVycyBraWprZW4gdWl0IG5hYXIgaGV0IG9udGdyZW5kZWxlbiB2YW4

2023-09-04, 04:15

<p><img src="https://gimg2.gateimg.com/image/article/16938070720904.jpg" alt=""></p>
<h2 id="h2-Crypto20Dagelijkse20Samenvatting20De20SEC20kan20gedwongen20worden20om20Bitcoin20spot20ETFs20goed20te20keuren20Vitalik20Buterins20speech20heeft20RAI20met20meer20dan208020doen20stijgen228876"><a name="Crypto Dagelijkse Samenvatting: De SEC kan gedwongen worden om Bitcoin spot ETFs goed te keuren, Vitalik Buterin’s speech heeft RAI met meer dan 80% doen stijgen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Dagelijkse Samenvatting: De SEC kan gedwongen worden om <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETFs goed te keuren, Vitalik Buterin’s speech heeft RAI met meer dan 80% doen stijgen</h2><p>De SEC kan worden gedwongen om de aanvraag goed te keuren voor <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> spot ETF’s.</p>
<p>Volgens The Block toont een onderzoeksrapport van JPMorgan analisten onder leiding van Nikolaos Panigrtzoglou aan dat de recente overwinning van Grayscale erop wijst dat de SEC mogelijk gedwongen wordt om in behandeling zijnde Bitcoin spot ETF-aanvragen van verschillende vermogensbeheerbedrijven, waaronder Grayscale, goed te keuren.</p>
<p>Analisten zijn van mening dat de SEC zijn eerdere goedkeuring voor op futures gebaseerde Bitcoin ETF’s moet intrekken om zijn ‘afwijzing van het voorstel van Grayscale om zijn Bitcoin-trustfonds om te zetten in een ETF’ te rechtvaardigen. Analisten voegden echter toe dat deze stap ‘zeer onhandig en verstorend is voor investeerders en onwaarschijnlijk lijkt’.</p>
<p>Hoewel de SEC alle ETF’s tot oktober heeft uitgesteld, is er geen reden om ze te weigeren tenzij er een nieuwe resolutie wordt verstrekt.</p>
<p>Dus vanuit alle aspecten van informatie is goedkeuring een kwestie van tijd. Als er in oktober van dit jaar een nieuwe reden wordt gevonden om het niet door te laten gaan, wordt het uitgesteld tot volgend jaar. Daarom is de verwachting van goedkeuring dit jaar of volgend jaar altijd aanwezig geweest, en ik geloof dat goedkeuring uiterlijk volgend jaar zal worden verkregen.</p>
<p>Als alternatief, beïnvloed door de opmerkingen van Vitalik, is de Reflexer-token gebaseerd op het stablecoin-protocol van RAI in 24 uur tijd met meer dan 80% gestegen en wordt nu geciteerd op $13.5. Er wordt begrepen dat Vitalik Buterin, bij deelname aan de Reflexer Finance Discord-discussie, heeft verklaard dat RAI, als de eerste stablecoin op het Reflexer-platform, een actieve voorstander kan worden van niet-populaire vloeibare stakingsderivaten (LSD’s).</p>
<p>Bovendien had het adres dat als Vitalik was gemarkeerd al op 11 maart 500 ETH’s gestort in Reflexer om 150.000 RAIs te casten.</p>
<p>Wat betreft gegevens, bereikte het handelsvolume op de spotmarkt van het Decentralized Trading Platform (DEX) in augustus $22,19 miljard, een nieuw dieptepunt sinds december 2020 ($21,9 miljard). Daarvan bedroeg het marktaandeel van <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> in augustus was 55,34%, een afname van ongeveer 5 procentpunten ten opzichte van 60,55% in juli.</p>
<p>Het handelsvolume van CEX op de spotmarkt in augustus bedroeg $422,95 miljard, een nieuw dieptepunt sinds oktober 2020 (met een maandelijks handelsvolume van $226,58 miljard). Daarnaast is het marktaandeel van Binance spot trading gedaald van 46,88% in juli naar 45,42% in augustus.</p>
<p>Token Unlocks data laat zien dat tokens voor 7 projecten deze week worden vrijgegeven, waarbij alleen IMX en HFT-bedragen van meer dan één miljoen Amerikaanse dollars worden vrijgegeven. Daaronder:</p>
<p>Om 3:06 uur (UTC) op 4 september zal Tornado Cash 22.800 TORNs ontgrendelen (ter waarde van ongeveer $61.000), wat ongeveer 1,51% van de omloopvolume vertegenwoordigt;</p>
<p>Om 0:00 uur (UTC) op 5 september zal Liquid 657.000 LQTY-eenheden ontgrendelen (ter waarde van ongeveer $541.000), wat overeenkomt met ongeveer 0,7% van het circulatievolume;</p>
<p>Om 12 uur ‘s middags (UTC) op 5 september zal Galxe 416.000 GAL’s ontgrendelen (ter waarde van ongeveer $466.000), wat overeenkomt met ongeveer 0,9% van het omloopvolume;</p>
<p>Op 5 september om 7:54 uur (UTC) zal LooksRare 12,5 miljoen LOOKS (ter waarde van ongeveer $674.000) vrijgeven, wat overeenkomt met ongeveer 2,29% van de omloopvolume.</p>
<p>Om 0:00 uur (UTC) op 7 september zal Hashflow 3,23 miljoen HFT’s ontgrendelen (ter waarde van ongeveer $1,07 miljoen), wat overeenkomt met ongeveer 1,84% van de omloopvolume;</p>
<p>Om 0:00 uur (UTC) op 8 september, <a href="/price/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">Moonbeam</a> zal 3,04 miljoen GLMR’s ontgrendelen (ter waarde van ongeveer $563.000), wat ongeveer 0,42% van het omloopvolume vertegenwoordigt;</p>
<p>Om 22:00 uur (UTC) op 8 september. <a href="/price/immutablex-imx" rel="nofollow noopener noreferrer" target="_blank">ImmutableX</a> zal 18,08 miljoen IMX’s ontgrendelen (ter waarde van ongeveer $9,81 miljoen), wat ongeveer 1,61% van de omloop vertegenwoordigt.</p>
<h2 id="h2-De20belangrijkste20tokentrends20van20vandaag494104"><a name="De belangrijkste tokentrends van vandaag" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De belangrijkste tokentrends van vandaag</h2><h3 id="h3-BTC20BTC988441"><a name="BTC (BTC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC (BTC)</h3><p><img src="https://gimg2.gateimg.com/image/article/1693807132BTC.png" alt=""><br>Aan het begin van de maand kende BTC een daling naar $25.333 en stabiliseerde zich vervolgens. De middellangetermijnstructuur vormt mogelijk een M-vormige trend of een kop- en schouderpatroon. Als het een M-vormige trend is, kan een korte positie worden overwogen wanneer het onder het vorige dieptepunt van $25.165 daalt, met een doel van $24.222. Als er een kop- en schouderpatroon ontstaat, kan het kopers verleiden om de prijs naar $30.203 te duwen, gevolgd door een snelle daling, wat mogelijk het einde van de hoogmarkt van dit jaar markeert.</p>
<h3 id="h3-WLD878279"><a name="WLD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WLD</h3><p><img src="https://gimg2.gateimg.com/image/article/1693807169WLD.png" alt=""><br>Op korte termijn lijkt WLD zijn eerder geïdentificeerde ondersteuningsniveau op $1.090 vast te houden en kan het een secundaire opleving ervaren. De middellangetermijnstructuur blijft echter bearish. Het wordt aangeraden om een snel-in, snel-uit strategie te hanteren voor oplevingen, met opwaartse doelen op $1.142 en $1.193.</p>
<h3 id="h3-CYBER514458"><a name="CYBER" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CYBER</h3><p><img src="https://gimg2.gateimg.com/image/article/1693807214CYBER.png" alt=""><br>Online aanwezigheid en populariteit opbouwen: Het CYBER-project was bedoeld om voldoende marktaandacht en secundaire liquiditeit te genereren door op LaunchPool te lanceren. Deze stap was cruciaal om de aandacht te vestigen op de secundaire markt en de basis te leggen voor vervolgstrategieën.</p>
<p>Het aantrekken van spot investeerders doorlopende volatiliteit: Na de lancering op CYBER bleef de prijsvolatiliteit in lijn met de Fibonacci-reeks, met een stabiele basisprijs van $3,53. Deze fase richtte zich op het consolideren van de marktstabiliteit, zelfs tijdens bredere marktdalingen, om massale verkopen te voorkomen.</p>
<p>Het opbouwen van contractposities en door volatiliteit gedreven handel: Tijdens de eerdergenoemde fase bouwden market makers geleidelijk een aanzienlijk aantal contractposities op via relatief goedkope handelsstrategieën. Gegevens van verschillende beurscontracten toonden een geleidelijke toename van de contractmarktkapitalisatie, variërend van $52 miljoen tot $96 miljoen tijdens de nacht van 29 augustus tot de ochtend van 30 augustus. De secundaire markt bereikte het initiële doel van $8.185, maar de contractposities op de markt namen niet af; in feite namen ze toe, wat aangeeft dat de initiële posities niet volledig werden gesloten. Vervolgens kende de markt een hoge volatiliteit.</p>
<p>Dit proces omvatte ook het benutten van liquidaties op de contractmarkt om longposities verder te vergroten (door negatieve financieringstarieven te benutten). Het belangrijkste was dat marktmakers nog steeds de spotmarktprijs controleerden, waardoor risico’s verbonden aan de handel in contractposities werden geminimaliseerd.</p>
<p>Liquidatie en Winsten op de Contractmarkt: De liquidatiestrategie voor CYBER was cruciaal. Market makers hebben een aanzienlijk aantal grote shortposities ingenomen op de contractmarkt en hebben retailbeleggers aangemoedigd om longposities te openen door middel van negatieve premies en hoge financieringstarieven.</p>
<p>Hoe heeft CYBER dit in zo’n korte tijd bereikt? De prijsstijging bereikte $16,10, in lijn met de negatieve rente van de contractmarkt op zijn maximale negatieve rente van -2,50%. In slechts vijf minuten bereikte de prijs $16,50, precies in lijn met een piek in de Fibonacci-reeks, en de maximale negatieve rente steeg snel tot -0,162%.</p>
<p>Dit suggereert aanzienlijke kapitaalinzet op de markt voor contractuele shortposities, mogelijk door middel van high-frequency trading, waarbij effectief gebruik wordt gemaakt van verschillen tussen de spot- en contractmarkten om aanzienlijke winsten te maximaliseren in een kort tijdsbestek.</p>
<p>In de wereld van financiën regeert kapitaal alles. Lege bekers maken geen geluid, maar gevulde kunnen tot dronkenschap leiden. Denk je dat er hier nog steeds een korte termijn spel is? Het lijkt erop dat de kansen afnemen naarmate de interesse afneemt.</p>
<h2 id="h2-Macro20Nonfarm20data20soft20landing20US20stock20market20closed20focus20on20crypto20trends15165"><a name="Macro: Non-farm data soft landing, US stock market closed, focus on crypto trends" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Non-farm data soft landing, US stock market closed, focus on crypto trends</h2><p>Het niet-agrarisch rapport dat afgelopen vrijdag werd vrijgegeven, hoewel in lijn met de trend van een ‘zachte landing’, steeg de Amerikaanse dollarkoers snel van de intraday dieptepunten en sloot 0,64% hoger op 104,28 vanwege de ‘havikachtige’ suggestie van voortgezette verkrapping door voorzitter Mester van de Cleveland Fed.</p>
<p>De Amerikaanse schatkistrendement bereikte een dieptepunt van drie weken na het rapport over de non-farm, maar herstelde zich daarna ook, waarbij het rendement op de Amerikaanse schatkist van 10 jaar steeg van 4,11% naar 4,18%; Het rendement op de Amerikaanse schatkist van twee jaar zag een kleine intraday-stijging van minder dan 2 basispunten.</p>
<p>Spot goud brak kort de $1.950 markering na de aankondiging van de niet-landbouwsector, maar viel vervolgens scherp terug door het ‘koude water’ dat Messer erover goot, waardoor het bijna $20 daalde en 0,02% lager sloot op $1.939,9/ounce. Spot zilver daalde drie opeenvolgende handelsdagen en sloot 1,05% lager.</p>
<p>Na de kwartaal enquête van augustus in de Verenigde Staten, registreerde de niet-landbouw werkgelegenheid-bevolking 187.000; De werkloosheidsgraad geregistreerd op 3,8%, een nieuw hoogtepunt sinds februari vorig jaar. Beide gegevens waren hoger dan verwacht. Na de vrijgave van de gegevens heeft de markt een lage waarschijnlijkheid dat de Federal Reserve de rentetarieven dit jaar opnieuw zal verhogen. De swapmarkt heeft de tijd volledig geprijsd voor de Federal Reserve om de rentetarieven met 25 basispunten te verlagen van juni volgend jaar tot mei.</p>
<p>Meister van de Federal Reserve verklaarde dat ondanks tekenen van een betere balans op de Amerikaanse arbeidsmarkt, de Amerikaanse arbeidsmarkt nog steeds sterk is. Ze wees er ook op dat de inflatie nog steeds te hoog is en toekomstige rentebeslissingen zullen worden genomen op basis van aankomende gegevensuitgaven.</p>
<p>Deze maandag is een vrije dag in de Verenigde Staten en de Amerikaanse markt zal gesloten zijn. We zullen ons richten op de trends op de cryptomarkt.</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 beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten voor op dit artikel. Het is toegestaan om het artikel opnieuw te plaatsen op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische stappen worden ondernomen wegens auteursrechtschending.<br></div><p></p><br></div></div></div></div>