Vm9sYXRpbGl0ZWl0c2RyZW1wZWwsIEJ1bGwgTWFya2V0IFRyaWdnZXI/OiBXZWtlbGlqa3NlIG1hcmt0dXBkYXRlIHZhbiBCbG9maW4gQWNhZGVteQ==

2023-03-10, 06:03

<p><img src="https://gimg2.gateimg.com/image/article/167842656311.png" alt=""><br>De rally van cryptos in lage liquiditeit zorgde voor een plotselinge stijging in volatiliteit, wat de eerste periode van hoge volatiliteit van 2023 veroorzaakte.</p>
<p>De stijging van de prijzen van crypto-activa hangt samen met veranderingen in de macro-economische omgeving. Tegelijkertijd kan de “gamma squeeze” op de markten met lage liquiditeit van spot- en derivaten niet worden genegeerd.</p>
<p>De verschuiving in het beleggerssentiment heeft het huidige prijsniveau ondersteund en de FOMC-vergadering deze week zal de sleutel zijn om de rally in stand te houden.</p>
<h2 id="h2-Rally20van20het20Nieuwjaar286437"><a name="Rally van het Nieuwjaar" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rally van het Nieuwjaar</h2><p>Naarmate de Nieuwjaarsvakantie van 2023 ten einde loopt, zijn de verwachtingen dat de “cyclus van renteverhogingen ten einde loopt” sterker geworden. Economische gegevens suggereren dat de recessie verwachtingen die vorig jaar begonnen op te stapelen, “belangrijker” zijn geworden als gevolg van een reeks scherpe renteverhogingen in 2022. Een van de meest gevoelige indicatoren van de economische cyclus, het verschil tussen de rendementen van T-Notes met een looptijd van 10 jaar en 2 jaar, bereikte een 40-jarig laagterecord, op één na de Volcker-periode.<br><img src="https://gimg2.gateimg.com/image/article/1678427479BLO1.png" alt=""><em>Het verschil tussen de opbrengsten van 10-jarige en 2-jarige T-Notes, per 31 januari 2023. Bron: <a href="TradingView.com" rel="nofollow noopener noreferrer" target="_blank" title="TradingView.com">TradingView.com</a></em></p>
<p>De groeiende dreiging van recessie heeft de Fed gedwongen om te overwegen zijn versoepelingsbeleid in zekere mate te versoepelen. Na het aannemen van agressief verkrappingsbeleid voor belangrijke kapitaalmarkten zoals de VS, de EU en Canada, zijn hun inflatieniveaus aanzienlijk gedaald, beter dan het gemiddelde van de OESO-landen. Tegelijkertijd daalden ook de PCE-gegevens terug naar een jaar geleden.<br><img src="https://gimg2.gateimg.com/image/article/1678427548BLO2.png" alt=""><em>CPI-veranderingen in geselecteerde belangrijke OESO-landen, per 31 januari 2023. Bron: <a href="oecd.org" rel="nofollow noopener noreferrer" target="_blank" title="oecd.org">oecd.org</a></em></p>
<p><img src="https://gimg2.gateimg.com/image/article/1678427618BLO3.png" alt=""><em>Wijzigingen in de Amerikaanse CPI, vanaf 31 januari 2023. Bron: <a href="tradingeconomics.com" rel="nofollow noopener noreferrer" target="_blank" title="tradingeconomics.com">tradingeconomics.com</a></em></p>
<p>Het is vermeldenswaard dat hoewel de scherpe renteverhoging een aanzienlijke impact heeft gehad op de economie, de gegevens van het bbp op korte termijn geen substantiële daling hebben laten zien en de werkloosheid nog geen aanzienlijke stijging heeft laten zien, wat wijst op een zekere mate van economische veerkracht. De situatie van ‘inflatie of recessie’ die in 2022 werd voorzien, is nog niet volledig werkelijkheid geworden en de mogelijkheid van een ‘zachte landing’ is relatief toegenomen.<br><img src="https://gimg2.gateimg.com/image/article/1678427689BLO4.png" alt=""><em>Veranderingen in het werkloosheidspercentage in de VS van januari 2022 tot heden, per 31 januari 2023. Bron: <a href="tradingeconomics.com" rel="nofollow noopener noreferrer" target="_blank" title="tradingeconomics.com">tradingeconomics.com</a></em></p>
<p><img src="https://gimg2.gateimg.com/image/article/1678427740BLO5.png" alt=""><em>Amerikaanse reële bbp-veranderingen vanaf 2019 tot heden, per 31 januari 2023. Bron: US Bureau of Economic Analysis</em></p>
<p>In de ogen van investeerders lijkt het redelijk om het tempo van renteverhogingen te vertragen: het is een betere kans voor centrale banken, en het handhaven van eerdere agressieve verkrappingsbeleid zal alleen maar leiden tot een recessie. De rentebeslissing van de Bank of Canada in januari heeft al een vergelijkbare houding getoond.</p>
<p>Gezien de consistentie van het beleid van de centrale banken in de VS en Canada, lijkt het erop dat de Federal Reserve ook ‘zou moeten’ de druk op het beleid verlichten. Rentehandelaren zijn ervan overtuigd dat de Fed geen recessie zal riskeren door de rente sterk te verhogen en verwachten niet dat de eindpuntrente hoger zal zijn dan 5%.<br><img src="https://gimg2.gateimg.com/image/article/1678428068BLO6.png" alt=""><em>De verwachtingen van de eindpuntrentes, per 31 januari 2023. Bron: CME Group</em></p>
<p>Optimistische verwachtingen van de Fed versoepelingsbeleid druk hebben beleggers aan de zijlijn om terug te keren naar de markten, wat leidt tot een nieuwjaarsrally in 2023. De Nasdaq steeg meer dan 12% aan het begin van het nieuwe jaar, en de SP500 index overschreed 4.000. Het lijkt erop dat er eindelijk een sprankje hoop is in de langdurige berenmarkt.<br><img src="https://gimg2.gateimg.com/image/article/1678428115BLO7.png" alt=""><em>De prestaties van de Nasdaq 100, per 31 januari 2023. Bron: <a href="TradingView.com" rel="nofollow noopener noreferrer" target="_blank" title="TradingView.com">TradingView.com</a></em></p>
<p><img src="https://gimg2.gateimg.com/image/article/1678428163BLO8.png" alt=""><em>De prestaties van S&amp;P 500, per 31 januari 2023. Bron: <a href="TradingView.com" rel="nofollow noopener noreferrer" target="_blank" title="TradingView.com">TradingView.com</a></em></p>
<p>Echter, aan het begin van de Amerikaanse aandelenrally volgde de cryptomarkt niet. Gezien de positie van de cryptomarkt in de liquiditeitsketen en de reeks gebeurtenissen die plaatsvonden eind 2022, lijkt de ‘langverwachte’ liquiditeit niet onredelijk. Terwijl het een reeks handelsmogelijkheden creëert, biedt de timing van de aankomst van liquiditeit ook extra tijd voor cryptowalvissen. De ‘Nieuwjaarsrally’ van de cryptomarkt staat klaar voor lancering.</p>
<h2 id="h2-Volatiliteitstrigger326781"><a name="“Volatiliteitstrigger”" class="reference-link"></a><span class="header-link octicon octicon-link"></span>“Volatiliteitstrigger”</h2><p>Tijdens de nieuwjaarsvakantie is de liquiditeit op de cryptomarkt gedaald tot het laagste niveau sinds 2021, met het maandelijkse volume van spot- en Delta 1-contracten in december 2022 bijna hetzelfde als eind 2020. Het uitputten van de liquiditeit betekent ook kansen: er is relatief weinig kapitaal nodig om de prijzen aanzienlijk op te drijven via operaties op de spot- en derivatenmarkten. De ‘Gamma Squeeze’ werd bekend tijdens het GME-evenement in 2021. Echter, op de cryptomarkt heeft de gamma squeeze bijna elk jaar plaatsgevonden sinds 2021.<br><img src="https://gimg2.gateimg.com/image/article/1678428274BLO9.png" alt=""><em>Veranderingen in de maandelijkse spot handelsvolume <a href="/price/optimism-op" target="_blank" class="blog_inner_link">op crypto</a> beurzen. Bron: The Block</em><img src="https://gimg2.gateimg.com/image/article/1678428315BLO10.png" alt=""> <em>Veranderingen in de maandelijkse handelsvolumes van Delta 1 contracten op crypto-beurzen. Bron: The Block</em></p>
<p>Een week voor de sterke stijging halverwege januari waren blockhandelaren begonnen met het kopen van callopties van BTC en ETH, wat druk zette op marktmakers om zich in te dekken. Rond 11 januari bereikten de Bitcoinprijzen meer dan $17k. Op dat moment hadden de marktmakers aanzienlijke negatieve gammablootstelling:<br><img src="https://gimg2.gateimg.com/image/article/1678428359BLO11.png" alt=""><em>BTC-opties GEX-distributie op 11 januari. Bron: Amberdata Derivaten</em></p>
<p>Gamma is een indicator die de versnelling van veranderingen in de prijs van opties ten opzichte van de onderliggende prijs meet, wat een van de belangrijkste risicoblootstellingen is waar optiehandelaren, vooral market makers, aandacht aan moeten besteden. Optie market makers zijn meestal delta neutraal en dekken hun risicoblootstellingen af door het kopen en verkopen van de onderliggende spot- of futures/perpetual-contracten. Bij verschillende gamma-niveaus nemen market makers doorgaans twee tegenovergestelde afdekkingsstrategieën aan:</p>
<p>● Op de uitoefenprijzen waar de gammablootstelling positief is, moeten marktmakers bij stijgende prijzen meer onderliggende activa verkopen om het aanvullende risico af te dekken. Bij dalende prijzen handhaven marktmakers zich delta-neutraal door onderliggende activa te kopen. Onder invloed van het “hoog verkopen en laag kopen”-gedrag van de marktmaker neemt het bereik van prijsbewegingen en marktvolatiliteit af.</p>
<p>● Echter, zodra de prijs zich verplaatst naar een positie waarbij de gamma blootstelling negatief is, keert de situatie volledig om. Naarmate de prijzen stijgen, moeten market makers activa kopen om extra risico af te dekken, en wanneer de prijzen dalen, verkopen market makers activa om delta neutraal te blijven. Gezien de omvang van het kapitaal van de market maker zal het gedrag van ‘opjagen en verkopen’ de marktvolatiliteit aanzienlijk verhogen.</p>
<p>● “Volatility Trigger” is de plek waar market makers hun dekkingsstrategieën omzetten. Dit concept werd voorgesteld door SpotGamma en andere Amerikaanse dienstverleners voor optiegegevens om de uitoefenprijzen van de schakelingsstrategieën te definiëren.</p>
<p>Met de opeenhoping van negatieve gamma moesten market makers veel spots en long Delta 1-contracten kopen — de ‘Gamma Squeeze’ begon. Hoewel de marktvolatiliteit nog niet is gestegen, is de ‘Volatiliteitstrigger’ al overgehaald en is de koopgolf in gang gezet.</p>
<p>Bij het bespreken van de “Volatility Trigger” moet ook rekening worden gehouden met een ander gerelateerd concept, namelijk de “Absolute Gamma Strike”. Absolute gamma strike verwijst naar de uitoefenprijs waarbij de market makers de hoogste positieve gamma hebben. Rond deze uitoefenprijs zijn veel hedging posities van market makers eraan gekoppeld. Bovendien maakt het hedging gedrag van de market makers deze uitoefenprijs ook tot een belangrijk ondersteunings-/weerstandsniveau in de markt. Zodra deze uitoefenprijs wordt doorbroken, zal de markt waarschijnlijk aanzienlijke volatiliteit ervaren.</p>
<p>Op 11 januari was de absolute gamma-strike ongeveer $19k. Echter, op 13 januari overtrof de spotprijs de uitoefenprijs omdat de stieren bleven kopen. Market makers hebben geen keus. Geconfronteerd met de negatieve gamma, is ‘kopen’ de enige optie:<br><img src="https://gimg2.gateimg.com/image/article/1678428511BLO12.png" alt=""><em>BTC opties GEX-distributie op 13 januari. Bron: Amberdata-derivaten</em></p>
<p>Of het nu vrijwillig of gedwongen is, het kopen op de hele markt heeft de prijzen van mainstream crypto-activa doen stijgen. Op één dag steeg de prijs van BTC en ETH met meer dan 10% en steeg de impliciete volatiliteit ook sterk. Volatiliteitsbulls en prijsbulls hebben hun eerste pot goud binnengehaald in 2023, terwijl de omvang van het liquideren van shorts een recordniveau bereikte in bijna 3 maanden.<br><img src="https://gimg2.gateimg.com/image/article/1678428560BLO13.png" alt=""><em>BTC-opties ATM IV’s prestaties in januari. Bron: Amberdata Derivatives</em></p>
<p><img src="https://gimg2.gateimg.com/image/article/1678428597BLO14.png" alt=""><em>Wijzigingen in de liquidatieschaal van Delta 1-contracten op de cryptomarkt, vanaf 1 februari 2023. Bron: Coinglass</em></p>
<p>Dit is echter niet het einde van de volatiliteit. Op 16 januari werden marktmakers geconfronteerd met een nog slechtere situatie: meer negatieve gamma op uitoefenprijzen in de buurt van de spotprijs. Ze moesten blijven hedgen en verdere aankopen op de markt stimuleren. Zelfs in OTC-markten liet het kopen een duidelijke markering achter, of het nu voor hedging was of gewoon om de dips te kopen.<br><img src="https://gimg2.gateimg.com/image/article/1678428647BLO15.png" alt=""><em>BTC-opties GEX-distributie op 16 januari. Bron: Amberdata Derivaten</em></p>
<p><img src="https://gimg2.gateimg.com/image/article/1678428688BLO16.png" alt=""><em>Totale OTC-desksaldo van BTC. Bron: Glassnode</em></p>
<h2 id="h2-Bullmarkt20Trigger643854"><a name="Bullmarkt Trigger?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bullmarkt Trigger?</h2><p>Op de futuresmarkt herstelde de BTC-futuresbasis voor de lange maand zich snel en werd de kloof met het rendement op 10-jaars T-Notes aanzienlijk kleiner. Op de optiemarkt keerde de scheefheid van BTC-opties voor het eerst sinds 2022 terug naar bullish, terwijl de scheefheid van ETH-opties ook terugkeerde naar neutraal.<br><img src="https://gimg2.gateimg.com/image/article/1678428766BLO17.png" alt=""><em>BTC opties scheefheid van januari 2022 tot 2 februari 2023. Bron: Amberdata Derivaten</em></p>
<p>Er is echter niet zoveel momentum voor verdere rallies. Vanuit een macro perspectief is het einde van de Fed renteverhogingen nog minstens enkele maanden verwijderd. Fed-functionarissen geloven dat als er meer bewijs is van afkoelende inflatie, Fed-functionarissen renteverhogingen kunnen pauzeren in 2023q2. Echter, de Fed zal alleen een pauze in renteverhogingen overwegen tijdens haar vergadering in mei als de neerwaartse trend in inflatie doorgaat in 2023q1.</p>
<p>Vanuit een micro-perspectief komt de enthousiasme van beleggers voornamelijk voort uit de verwachting van het ‘einde van renteverhogingen’, en de kern van het ondersteunen van prijzen - voldoende liquiditeit, is nog niet teruggekeerd.</p>
<p>Het is niet moeilijk te zien dat voor en na het opdrijven van de prijs tot ongeveer $23k, het wekelijkse handelsvolume van de opties snel daalde, zelfs lager dan het volume tijdens de kerstvakantie. De verwachtingen van investeerders lijken tot op zekere hoogte te zijn geprijsd: in de buurt van de $23k uitoefenprijs van de BTC-opties is de nieuwe absolute gammastaking gevormd en de prijs zit stevig ‘vast’.<br><img src="https://gimg2.gateimg.com/image/article/1678428820BLO18.png" alt=""><em>Het wekelijkse handelsvolume van BTC-opties van december 2022 tot op heden, per 2 februari 2023. Bron: Amberdata Derivatives</em><img src="https://gimg2.gateimg.com/image/article/1678428862BLO19.png" alt=""> <em>BTC opties GEX-distributie op 1 februari. Bron: Amberdata Derivatives</em></p>
<p>Hoewel de 25bps renteverhoging volledig in de markt is verdisconteerd, is het liquiditeitsbeleid van de Fed in 2023 nog steeds onbekend. Daarom is de verklaring van de Fed cruciaal.</p>
<p>Vanuit het perspectief van gamma-belichting, als de verklaring van de Fed bevooroordeeld is ten gunste van duifachtigheid onder dreiging van recessie, zal de verdere opleving van de cryptoprijzen niet veel weerstand ondervinden. Daarentegen kan een havikachtige verklaring de huidige steunen doorbreken en de pasgevormde ‘Volatility Trigger’ nabij de uitoefenprijs van $23k trekken. Hoewel investeerders al lange tijd bidden voor een terugkeer van een stierenmarkt, is het nog steeds nodig om wat puts te kopen als verzekering bij het kopen van dips.</p>
<p><strong><em>Openbaarmaking: Dit artikel is geschreven in samenwerking met Blofin</em></strong></p>
<div class="blog-details-info"><br><div>Auteur:<strong> Blofin</strong><br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen beleggingsadvies.<br></em><div class="info-tips"><em></em>Geen inhoud hierin vormt beleggingsadvies en vormt geen enkel aanbod of verzoek om een ​​beleggingsproduct of project aan te bieden of aanbeveling te doen.<br><div class="info-tips"><em>De opname van producten, diensten, entiteiten of inhoud van derden vormt geen goedkeuring, aanbeveling of affiliatie door Gate.io. Voer grondig onderzoek uit en zoek professioneel advies voordat u investeringsbeslissingen neemt.<br></em><div class="info-tips"><em></em>Gate.io behoudt alle rechten op dit artikel. Herposten van het artikel zal worden toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<p></p><br><br><p></p></div><p></p><br></div></div></div></div></div>