S29uIGVlbiAkNSBtaWxqYXJkIEJpdGNvaW4gV2FsdmlzdmVya29vcCBkZSBkYWFyb3B2b2xnZW5kZSBCVEMgcHJpanNkYWxpbmcgaGViYmVuIHZlcm9vcnphYWt0IG5hIGRlIGxhbmNlcmluZyB2YW4gZGUgRVRGPw==

2024-01-31, 03:17

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR138"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>Een crypto-analist, James Van Straten, zei dat de recente daling van $9.000 in de prijs van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> werd veroorzaakt door een enkele walvis die veel <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">bitcoin</a> verkocht.</p>
<p>De walvis die 100.000 BTC verkocht, maakte een winst van meer dan $100 miljoen.</p>
<p>Satoshi Nakamoto, Brian Armstrong, Chris Larsen, Michael Saylor, Changpeng Zhao, The Winklevoss Twins, Barry Silbert, Jed McCaleb en Tim Draper zijn voorbeelden van de grootste bitcoin walvissen.</p>
<h2 id="h2-Inleiding605908"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Veel factoren beïnvloeden de prijs van digitale activa zoals cryptocurrencies, maar met verschillende magnitudes. Echter, vraag en aanbod hebben de grootste invloed op de waarde van crypto-activa. Zoals we weten, wanneer het aanbod groter is dan de vraag, daalt de prijs van het activum.</p>
<p>In de crypto sector kan de activiteit van walvissen invloed hebben op de prijs van crypto activa. In deze analyse zullen we ueren of de recente grote verkoop van bitcoin heeft geleid tot de BTC-prijsdaling. We zullen ook de mogelijkheid van meer grote bitcoin-verkopen beoordelen.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/3376/16-new-bitcoin-btc-addresses-appear-in-a-single-day-crypto-whales-on-the-move &quot;16 New Bitcoin (BTC" rel="nofollow noopener noreferrer" target="_blank">16 Nieuwe Bitcoin (BTC) Adressen Verschijnen Op Eén Dag</a> Adressen verschijnen op één dag</p>
<h2 id="h2-Een20enkele20walvis20kan20de20prijs20van20Bitcoin20met20meer20dan20900020hebben20doen20crashen212532"><a name="Een enkele walvis kan de prijs van Bitcoin met meer dan $9.000 hebben doen crashen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Een enkele walvis kan de prijs van Bitcoin met meer dan $9.000 hebben doen crashen</h2><p>Enkele dagen na de lancering van bitcoin ETF’s begon de prijs van bitcoin te dalen naar de huidige prijs van $42.032. In feite daalde de BTC-prijs in de tweede week van januari met meer dan $9.000, wat de cryptosector schokte, gezien de verwachting van de gemeenschap dat de waarde zou stijgen als gevolg van de goedkeuring van de ETF’s.<br><img src="https://gimg2.gateimg.com/image/article/1706670680WD1Liolq72.jpg" alt=""><br>Bitcoin Prijs - Coingecko</p>
<p>Zoals u kunt zien op het diagram, was er een scherpe <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin prijs</a> vallen op 11 januari. Sommige analisten zeiden dat de daling het gevolg was van een afkoelperiode na de goedkeuring door de SEC van spot bitcoin ETF-aanvragen. In feite werd de vrije val van de bitcoinprijs die begon op 12 januari toegeschreven aan het ‘verkoop het nieuws’-evenement in verband met de goedkeuring van de cryptofondsen in de Verenigde Staten.</p>
<p>Lees ook: <a href="https://www.gate.io/blog_detail/2852/crypto-whale-buys-3.43-t-pepe-as-meme-coin-surge-70" target="_blank">Crypto Whale koopt 3,43 T PEPE als Meme Coin Surge 70%</a></p>
<p>Er is echter een nieuwe theorie opgedoken over de plotselinge daling van de bitcoinprijs. James Van Straten, een onderzoeks- en gegevensanalist bij CryptoSlate - een crypto-inzichtenbedrijf - denkt dat de recente scherpe daling van de BTC-prijs het gevolg was van een transactie door een BTC-walvis die het actief in 2021 heeft gekocht, het heeft vastgehouden en vervolgens heeft verkocht tijdens de tweede week van januari 2024.</p>
<p>In een bericht op X beschuldigde Straten een nog onbekende bitcoin-walvis van de plotselinge daling van de bitcoin-prijs. In zijn onderzoeksbevindingen zei hij dat een van de lange termijn bitcoin-houders, die tijdens de bullrun van 2021 100.000 BTC ter waarde van $4,8 miljard heeft verworven, break-even speelde tegen een prijs van $49.000, waardoor hij/zij zijn bitcoin-positie kon verkopen.</p>
<p>Straten verduidelijkte zijn standpunt in een bericht op X. <a href="https://twitter.com/jvs_btc/status/1747918922941079866/photo/1" rel="nofollow noopener noreferrer" target="_blank">Hij zei</a>, “Dit is de reden waarom (naar mijn mening) Bitcoin op 12 januari zijn grootste 1-daagse opname had sinds de ineenstorting van FTX en tankte nadat de ETF begon te handelen.”</p>
<p>Hij voegde eraan toe: ‘Ik nam aan dat het zou worden gehouden vanwege een ongerealiseerd verlies van 75%.’ De omvang van de verkoop was zo groot dat het de daling van de bitcoin-prijs op één dag veroorzaakte. Volgens de norm was dat de grootste duik in de bitcoin-prijs sinds de ineenstorting van FTX.</p>
<p>Zoals het feit staat, <a href="https://www.gate.io/learn/articles/what-are-cryptocurrency-whales/714" target="_blank">de cryptowalvis bleef veerkrachtig</a> door een grote hoeveelheid bitcoin vast te houden. Belangrijker nog, er waren veel dalingen en stijgingen van de bitcoin prijs tussen 2021 en december 2023. Op een gegeven moment daalde de prijs van bitcoin tot ongeveer $16.000 in 2023.</p>
<p>Die crypto-walvis heeft waarschijnlijk meer dan $100 miljoen aan winst geboekt na die historische BTC-verkoop. De berekening om te schatten <a href="https://www.gate.io/blog_detail/1340/what-are-crypto-whales-and-how-do-you-track-them" target="_blank">de winst van de cryptowalvis is heel eenvoudig</a>. Rekening houdend met het feit dat de bitcoin-houder 100.000 BTC had, leidt een verschil van $1.000 tussen de instapprijs en de verkoopprijs tot een winst van $100 miljoen, wat een waardevol financieel voordeel is ondanks het aanhouden van het actief gedurende meer dan 2 jaar.</p>
<p>Desalniettemin is het belangrijk om op te merken dat de verkoop van de walvis slechts een trigger was van de prijsdaling. Opmerkelijk is dat de markt na die verkoop te maken kreeg met liquidaties. Hierover merkte Straten op: “Dat zette de markt in een frenzy, gecombineerd met liquidaties, ‘verkoop het nieuws’ en recordverliezen.”</p>
<h2 id="h2-Het20vooruitzicht20van20voortdurende20grote20BTCverkopen845070"><a name="Het vooruitzicht van voortdurende grote BTC-verkopen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het vooruitzicht van voortdurende grote BTC-verkopen</h2><p>Van Straten gelooft dat we tijdens 2024 verdere grote BTC-verkopen kunnen zien. Bovendien kunnen meerdere van deze verkopen plaatsvinden in het eerste kwartaal.</p>
<p>De deelname van grote institutionele beleggers die de macht hebben om de marktsentiment en prijs te beïnvloeden, toont aan dat we ons in een nieuwe crypto-tijdperk bevinden. Dit brengt ook complexiteit en onvoorspelbaarheid met zich mee in de industrie.</p>
<p>In <a href="https://twitter.com/hoss_crypto/status/1748447307266220533" rel="nofollow noopener noreferrer" target="_blank">een X-post, Kiarash Hossainpour, oprichter van Colorways Ventures</a> heeft aangegeven dat de markt tijdens de eerste helft van 2024 mogelijk te maken krijgt met verschillende grote BTC-verkopen die naar alle waarschijnlijkheid een grote invloed zullen hebben op de prijs ervan.</p>
<p>Ten eerste merkte Hossainpour op dat Grayscale Bitcoin Trust (GBTC) tijdens die periode mogelijk verdere verlagingen van zijn bezittingen kan doorvoeren. Na de lancering van de spot bitcoin ETF’s heeft het al zijn BTC-bezit verlaagd van 621.000 BTC naar onder de 580.000 BTC. Elke andere grote verkoop kan de bitcoinkoers verder omlaag duwen. Het is echter op dit moment nog niet duidelijk of het opnieuw van plan is om bitcoin te verkopen.</p>
<p>De andere verkoopdruk kan afkomstig zijn van Mt Gox, dat meer dan 138.000 BTC, ter waarde van ongeveer $5,8 miljard, aan zijn crediteuren wil vrijgeven na tien jaar insolventieprocedures. Als het erin slaagt om de bitcoin aan de crediteuren te verstrekken, kan dat resulteren in massale verkopen.</p>
<p>Verder kunnen de insolventieprocedures van Celsius en FTX leiden tot een verdeling van meer dan 38.000 BTC ($1,6 miljard) en respectievelijk 20.500 BTC ($850 miljoen). Als sommige ontvangers die mogelijk bitcoin-walvissen worden, ze omzetten in contanten, kan dat leiden tot grote verkopen.</p>
<p>Ook kunnen sommige mijnwerkers die grote bitcoinbezitters zijn, hun bezittingen verkopen gedurende het jaar. Desalniettemin, als de waarde van bitcoin verder daalt, zou dat andere cryptobeleggers de kans kunnen geven om <a href="/how-to-buy/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Koop Bitcoin</a>.</p>
<h2 id="h2-De20grootste20Bitcoinwalvissen20aller20tijden930488"><a name="De grootste Bitcoin-walvissen aller tijden" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De grootste Bitcoin-walvissen aller tijden</h2><p>Zoals eerder besproken, als grote bitcoin-houders bitcoin verkopen, kan de prijs ervan dalen. Op dit moment zijn er tientallen bitcoin-walvissen die ervoor kunnen kiezen om op elk moment hun BTC-posities af te stoten.</p>
<p>voorbeelden van <a href="https://www.gate.io/blog_detail/451/btc-whale-holders-is-it-possible-to-know-who-they-are" target="_blank">Bekende bitcoin-walvissen zijn onder andere</a> Satoshi Nakamoto, <a href="https://www.gate.io/learn/articles/who-is-satoshi-nakamoto/286" target="_blank">de oprichter van de bitcoin blockchain</a>, <a href="https://www.gate.io/blog_detail/139/r2f0zs5pbybpynnlcnzhdglvbjogvghlihrvccbzaxggy3j5chrvy3vycmvuy3kgbwfnbmf0zxmgyw5kihrozwlyihdhexmgdg8gz2v0ihjpy2gh" target="_blank">Brian Armstrong</a>, Chris Larsen, Michael Saylor, Changpeng Zhao, The Winklevoss Twins, Barry Silbert, Jed McCaleb en Tim Draper. De meesten van hen hebben grote belangen in grote cryptoprojecten zoals cryptocurrency-beurzen en toonaangevende blockchains.</p>
<h2 id="h2-Conclusie869573"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>James Van Straten zei dat een grote verkoop van bitcoin door een bitcoin-walvis heeft geleid tot de recente prijsdaling van $9.000 die heeft plaatsgevonden <a href="https://www.gate.io/learn/articles/ten-years-of-hard-work-written-after-the-us-bitcoin-spot-etf-was-approved/1559" target="_blank">na de goedkeuring van BTC ETF’s door de Amerikaanse SEC</a>. Er is een grote mogelijkheid van andere grote bitcoin verkopen, aangezien er verschillende grote instellingen zoals Celsius en Mt Gox zijn die bitcoin willen verspreiden onder hun crediteuren. Sommige ontvangers kunnen bitcoin in grote hoeveelheden verkopen.</p>
<h2 id="h2-Veelgestelde20vragen20over20Bitcoin20Walvissen292493"><a name="Veelgestelde vragen over Bitcoin Walvissen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over Bitcoin Walvissen</h2><h3 id="h3-Hoeveel20kosten20de20bitcoinwalvissen697334"><a name="Hoeveel kosten de bitcoin-walvissen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoeveel kosten de bitcoin-walvissen?</h3><p>De algemene opvatting is dat een individu, een organisatie of overheid die ten minste 10.000 BTC of bitcoin bezit met een waarde van ten minste $ 100.000 een crypto-walvis is. Er zijn op dit moment veel bitcoin whales op de markt.</p>
<h3 id="h3-Verkopen20walvissen20BTC91863"><a name="Verkopen walvissen BTC?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verkopen walvissen BTC?</h3><p>Onlangs hebben Bitcoin-walvissen Bitcoin verkocht sinds het begin van januari 2023. Ze verkopen meestal hun BTC-holdings op een punt waar ze winst kunnen maken of op zijn minst quitte kunnen spelen.</p>
<h3 id="h3-Wie20zijn20de20grootste20bitcoinhouders788515"><a name="Wie zijn de grootste bitcoin-houders?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wie zijn de grootste bitcoin-houders?</h3><p>Satoshi Nakamoto, Brian Armstrong, Chris Larsen, Michael Saylor, Changpeng Zhao, The Winklevoss Twins, Barry Silbert, Jed McCaleb en Tim Draper zijn enkele voorbeelden van de grootste bitcoin-walvissen.</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 beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>