TmFkZXJlbmRlICQ3ODAgQlRDLW9wdGllczogWmFsIGRlIEJpdGNvaW4tcHJpanMgcmVhZ2VyZW4=

2023-06-01, 01:43

<p><img src="https://gimg2.gateimg.com/blog/1679447253500249423shendu.jpeg" alt=""></p>
<h2 id="h2-TL20DR133964"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>29.000 <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ter waarde van ongeveer $780m stonden op het punt om op 19 mei te verlopen, wat de prijs van BTC zou kunnen beïnvloeden. De put-to-call ratio van 0.81 laat zien dat de markt neutraal tot bullish is.</p>
<p>Analisten voorspellen dat de waarde van BTC naar verwachting zal schommelen tussen $21.762,44 en $40.769,03 tegen het einde van 2023.</p>
<h2 id="h2-Introductie134711"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De meeste cryptocurrencies hebben <a href="https://www.gate.io/bitwiki/detail/284/derivatives" target="_blank">afgeleiden</a> die verbonden zijn met hun waarden. Als zodanig kan de hoeveelheid derivaten op de markt van invloed zijn op de richting van de prijsbewegingen van de onderliggende activa zoals ETH of Bitcoin. De <a href="https://www.gate.io/price/view/derivatives" target="_blank">openen of sluiten van derivatenposities</a> kan ook invloed hebben op de prijzen van de onderliggende cryptocurrencies. In deze gids bespreken we de mogelijke effecten van het verlopen van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> opties op 19 mei 2023.</p>
<h2 id="h2-78020miljoen20verloopt20op201920mei780045"><a name="$780 miljoen verloopt op 19 mei" class="reference-link"></a><span class="header-link octicon octicon-link"></span>$780 miljoen verloopt op 19 mei</h2><p>29.000 Bitcoin-opties ter waarde van $780 miljoen stonden op het punt te verlopen op 19 mei 2023, waardoor er onzekerheid ontstond op de markt, aangezien dit mogelijk tot veranderingen in de BTC-prijs kan leiden. Overigens zijn onlangs veel derivatenhandelaren overgestapt van ETH naar BTC. Volgens GreeksLive hadden de BTC-opties die op 19 mei zouden verlopen een pijnlijk punt van $27.500.</p>
<p>Als een punt, <a href="https://www.gate.io/price/view/options" target="_blank">Bitcoin-opties</a> zijn derivatencontracten waarmee handelaren kunnen speculeren op de waarde van BTC zonder deze te hoeven vasthouden. In de eerste plaats stellen de BTC-opties handelaren in staat om te <a href="https://www.gate.io/how-to-buy/bitcoin-btc" target="_blank">verkoop of koop Bitcoin</a> contracten tegen een vooraf bepaalde prijs, de uitoefenprijs, op een bepaalde vervaldatum.</p>
<p>De maximaal pijnwaarde, zoals hierboven vermeld, is de prijs waarop de meeste verliezen optreden wanneer het contract afloopt. Daarom is $27.500 in dit g een belangrijk referentiepunt. Dienovereenkomstig. <a href="https://metrics.deribit.com/options/BTC" rel="nofollow noopener noreferrer" target="_blank">gegevens op Deribit tonen aan</a> dat er een totaal openstaand belang is van 308.044. Belangrijker nog, Bitcoin-opties zijn beter dan Bitcoin-futures. Dit komt doordat de futures vaste vervaldatums hebben.</p>
<p>Een soortgelijke situatie bestaat in het <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> afgeleide markt waar 169.000 ETH-opties zijn die nog moeten verlopen. In vergelijking daarmee zijn de ETH-opties neutraler dan die van BTC, omdat ze een put/call-verhouding van 0,96 hebben.</p>
<p>Het aflopen van de BTC-opties zal waarschijnlijk leiden tot schommelingen in de prijs van bitcoin onder $26.000. Dit volgt op het verlies van BTC-momentum op 15 mei, toen de prijs onder het weerstandsniveau van $27.500 daalde. Het nieuws over aanstaande regelgevingsdruk op cryptocurrencies heeft waarschijnlijk geleid tot deze neerwaartse spiraal van de BTC-prijs.</p>
<p>Bijvoorbeeld, het nieuws afkomstig van de Securities and Exchange Committee (SEC) dat de meeste cryptocurrencies effecten zijn, heeft waarschijnlijk de enthousiasme van de markt getemperd. Zoals verwacht, zullen alle cryptocurrencies die als effecten zijn geclassificeerd, onder streng toezicht van de SEC komen te staan, wat hun marktgroei zal belemmeren. Bovendien heeft SEC-voorzitter Gary Gensler de opvatting geuit dat netwerknodes de Amerikaanse effectenwetten schenden, wat verdere onzekerheid op de markt creëert.</p>
<p>Ontwikkelingen in het Verenigd Koninkrijk laten ook zien dat de overheid haar controle op cryptocurrencies wil vergroten. Zo heeft de Schatkistcommissie van het Verenigd Koninkrijk op 17 mei bijvoorbeeld aanbevolen dat crypto-investeringsactiviteiten <a href="https://www.gate.io/trade/BTC_USD" target="_blank">zoals BTC-handel</a> behandeld worden als gokken op basis van het ‘principe van hetzelfde risico, hetzelfde regulerende resultaat’.</p>
<p>De reden voor deze positie is dat de meeste cryptocurrencies zoals Bitcoin en ETH niets hebben dat hen ondersteunt. Daarom verklaart de huidige onzekerheid op de markt de recente stap van sommige Bitcoin-handelaren om hun blootstelling aan BTC-investeringen te verminderen. Het bearish sentiment komt na de recente bitcoin-revolutie die de introductie van Bitcoin NFT’s, Bitcoin Virtual Machine en BRC-20 tokens omvatte, die de drijvende krachten waren achter opwaartse prijsbewegingen tijdens het eerste kwartaal.</p>
<h2 id="h2-Stieren20waren20optimistisch20over20Bitcoinopties702483"><a name="Stieren waren optimistisch over Bitcoin-opties" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Stieren waren optimistisch over Bitcoin-opties</h2><p>Met betrekking tot de op 19 mei vervallende BTC-opties waren de stieren zeer optimistisch. Als gevolg daarvan waren hun weddenschappen geconcentreerd boven de $28.000. Een specifieke reden voor dat optimisme was de stijging van 7% van BTC tussen 12 en 15 mei, waarbij het $27.500 weerstandsniveau werd getest.</p>
<p>De put-to-call-verhouding voor de Bitcoin-opties is 0,81, wat aangeeft dat het bullish is. Dit komt doordat een verhouding onder 1,00 wijst op een bullish markt, aangezien de meeste handelaren bereid zullen zijn om long-contracten te kopen in plaats van short-contracten. Echter, aangezien het cijfer dicht bij 1,00 ligt, toont het ook aan dat het marktsentiment neutraal tot bullish is. Daarentegen wijst een verhouding boven 1,0 op een bearish markt.</p>
<p>Het diagram hieronder geeft een samenvatting van de verwachte vervaldatum van BTC-opties.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16855835512871685583519_.pic.jpg" alt=""><br>Bitcoin-opties OI - Greekslive</p>
<h2 id="h2-Bitcoin20prijsanalyse19490"><a name="Bitcoin prijsanalyse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitcoin prijsanalyse</h2><p>Op het moment van schrijven, 26 mei, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> is $26,636.76, na een stijging van 1.26% in de afgelopen 24 uur, maar over het algemeen een verlies van 1.02% in de afgelopen 7 dagen. De onderstaande grafiek geeft een volledig beeld van de prijsprestaties van Bitcoin in mei.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16855835762881685583531_.pic.jpg" alt=""><br>Bitcoin Prijs - CoinMarketCap</p>
<p>Zoals opgemerkt, <a href="/price/the-graph-grt" rel="nofollow noopener noreferrer" target="_blank">The Graph</a> laat zien dat de prijs van BTC sinds 11 mei onder de $27.000 zweefde maar boven de $26.000 lag. Aan de andere kant is de waarde ervan sinds 25 mei gestegen, wat duidt op een bullish markt.</p>
<h2 id="h2-BTC20prijsvoorspelling72719"><a name="BTC prijsvoorspelling" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC prijsvoorspelling</h2><p>De meeste analisten voorspellen dat de prijs van Bitcoin zal stijgen in de rest van 2023. Bijvoorbeeld, <a href="https://coinpriceforecast.com/bitcoin-forecast-2020-2025-2030" rel="nofollow noopener noreferrer" target="_blank">Muntprijsvoorspelling</a> schat dat de prijs van Bitcoin tegen het einde van 2023 rond de $35.391 zal liggen. Het voorspelt ook dat de BTC-prijs in juni $28.687 zal bereiken.</p>
<p>Aan de andere kant, <a href="https://bitcoinwisdom.com/bitcoin-btc-price-prediction/" rel="nofollow noopener noreferrer" target="_blank">Bitcoinwisdom voorspelt</a> dat de prijs van BTC rond de $40.769,03 zal liggen in 2023. Het schat dat de prijs geleidelijk zal toenemen gedurende de resterende maanden.</p>
<p>Tot slot geeft Changelly een betere uitsplitsing van de verandering in de prijs van BTC. Het voorspelt dat de waarde ervan in juni $28,115.12 kan bereiken, in juli $29,535.63 en in augustus $30,398.73. Verder stelt het dat de opwaartse trend van BTC zal blijven aanhouden tot september, wanneer het waarschijnlijk $30,439.70 zal bereiken.</p>
<p>Desalniettemin stelt Changelly dat de waarde van Bitcoin in oktober kan dalen tot $28.248,92 en in november tot $24.275,87. Het gelooft ook dat de BTC-prijs zal schommelen tussen $21.762,44 en $26.307,76 in december.</p>
<p>Hier is Gate’s BTC <a href="https://www.gate.io/tw/blog_detail/26" target="_blank">prijsvoorspellingen voor 2025</a>.</p>
<h2 id="h2-Conclusie986696"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Op 19 mei zouden ongeveer 29.000 Bitcoin-opties ter waarde van ongeveer $780 miljoen aflopen, wat mogelijk invloed zou hebben op de <a href="https://www.gate.io/price/bitcoin-btc" target="_blank">prijs van BTC</a> De Bitcoin-revolutie die we in het eerste kwartaal van 2023 hebben meegemaakt, heeft individuen aangetrokken om te investeren in Bitcoin. Belangrijk is dat de prijsvoorspellingen van BTC wijzen op een ​​heldere Bitcoin-toekomst, omdat analisten verwachten dat de waarde ervan geleidelijk zal stijgen binnen de komende drie tot vier maanden.</p>
<h2 id="h2-Veelgestelde20vragen805146"><a name="Veelgestelde vragen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen</h2><h2 id="h2-Hoe20laat20verlopen20BTCopties756156"><a name="Hoe laat verlopen BTC-opties?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe laat verlopen BTC-opties?</h2><p>De BTC-opties verlopen vaak op verschillende tijden en dagen, afhankelijk van de beurs waarop je ze vindt. Bij sommige beurzen verlopen BTC-opties om 16.00 uur Londense tijd op vrijdagen.</p>
<h2 id="h2-Wat20gebeurt20er20wanneer20opties20aflopen20cryptos594832"><a name="Wat gebeurt er wanneer opties aflopen cryptos?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat gebeurt er wanneer opties aflopen cryptos?</h2><p>Wanneer de opties vervallen, ontvangen de kopers het onderliggende actief zoals Bitcoin of krijgen ze de winst uit de prijswijziging van de optie. In feite transfereren de partijen het saldo naar elkaar.</p>
<h2 id="h2-Wat20is20BTC20bij20optiehandel620059"><a name="Wat is BTC bij optiehandel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is BTC bij optiehandel?</h2><p>Bij optiehandel is BTC het financiële contract tussen twee partijen dat de optiehouder het recht geeft, maar niet de verplichting, om een bepaalde hoeveelheid Bitcoin te kopen of te verkopen tegen een bepaalde prijs en datum. Hoewel de optiehouder het recht heeft om te kiezen of hij al dan niet BTC koopt, is de verkoper verplicht om aan het verzoek van de houder te voldoen.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Mashell C.</strong>, Gate.io-onderzoeker<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 wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>