RGUgaW1wYWN0IHZhbiBoZXQgSXNyYcOrbGlzY2gtUGFsZXN0aWpuc2UgY29uZmxpY3Qgb3AgZGUgY3J5cHRvbWFya3Q=

2023-10-10, 06:35

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR608038"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Oorlog heeft in eerste instantie invloed op de echte economie en de aandelenmarkt, vooral in sectoren zoals energie, militair, luchtvaart en transport.</p>
<p>Terugkijkend op het voorgaande conflict tussen Rusland en Oekraïne en het huidige Israëlisch-Palestijnse conflict, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> toont geen significante risicoaversie.</p>
<p>Sommige conceptuele valuta’s die verband houden met digitale betalingen in strijdende landen kunnen profiteren van een toename.</p>
<h2 id="h2-Introductie765924"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Sinds 7 oktober is er een grootschalig gewapend conflict uitgebroken tussen de Palestijnse organisatie Hamas en Israël. Naarmate de oorlogssituatie blijft escaleren, hebben de financiële markten hier ook dienovereenkomstig op gereageerd. Dit artikel zal het Israëlisch-Palestijnse conflict als voorbeeld nemen om de impact van oorlog op de cryptomarkt te verkennen.</p>
<h2 id="h2-De20marktimpact20van20het20IsralischPalestijnse20conflict730077"><a name="De marktimpact van het Israëlisch-Palestijnse conflict" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De marktimpact van het Israëlisch-Palestijnse conflict</h2><p>Sinds 7 oktober is Israël in oorlog met de Palestijnse radicale organisatie Hamas, wat duizenden slachtoffers heeft veroorzaakt en de oorlogsvlammen naar buurlanden heeft verspreid. Ook Libanon en anderen hebben de oorlog verklaard om zich bij de strijd aan te sluiten. De Amerikaanse president Biden, die altijd Israël heeft gesteund, heeft vervolgens aangekondigd dat hij Israël zal blijven steunen.</p>
<p>Dit conflict is nog steeds gaande, en hoewel het bespreken van de impact van oorlog op onze investeerders misschien niet tijdig is, waarderen we vrede zeer en hopen we erop. Het is echter ook noodzakelijk om dit evenement te gebruiken om de marktimpact te ordenen, zodat we een meer scherpzinnig en alomvattend beeld van de wereld en de markt kunnen hebben, en de algehele waardeverhoging van de maatschappij die voortvloeit uit een vredige omgeving kunnen koesteren.</p>
<p>Over het algemeen wordt bij het uitbreken van een oorlog de reële economie het eerste geraakt, wat de basisbegrip van oorlog is. De stagnatie van de productie en economie van ondernemingen heeft een grote impact gehad op de productie en het leven van mensen.</p>
<p>De impact van oorlog op financiële markten treft meestal eerst de aandelenmarkt en wekt de aandacht van mensen voor veilige havenfondsen. Neem het huidige Israëlisch-Palestijnse conflict als voorbeeld, de energie- en militaire sectoren leidden de weg in winsten, terwijl luchtvaartaandelen leden. Door meerdere luchtvaartmaatschappijen die de Israëlische routes opschortten, daalden de aandelen van luchtvaartmaatschappijen over het algemeen, waarbij United Airlines, Delta Airlines en American Airlines gisteren meer dan 4% daalden. In vergelijking daarmee steeg ParaZero, de Israëlische leverancier van droneveiligheidsoplossingen, met 132%.</p>
<p>Ondertussen zorgde het Israëlisch-Palestijnse conflict voor een risicoaversie, waarbij de goudprijzen met 1,04% stegen. Bovendien, hoewel zowel Palestina als Israël geen olie produceren, is het conflictgebied het transportgebied voor ruwe olie uit het Midden-Oosten, wat ook invloed zal hebben op de olievoorziening. Aan het einde van de handelsdag steeg Amerikaanse olie met 4,34% en steeg Brent-ruwe olie met 4,22%.</p>
<p>Het is vermeldenswaardig dat de Israëlische aandelenmarkt. Na het uitbreken van het conflict daalde de Israëlische ETF met meer dan 7%, wat de grootste daling sinds maart 2020 markeert. Na een scherpe daling van meer dan 6% op zondag bleef de Israëlische aandelenmarkt op maandag lager openen, met een daling van meer dan 1% tijdens de sessie. Toch kondigde de Bank van Israël in de sessie aan dat ze zou investeren in liquiditeit om de volatiliteit van de shekel (Israëlische fiat) wisselkoers te verlichten, en vervolgens stopte de Israëlische aandelenmarkt met dalen en draaide naar boven, met een stijging van bijna 1% bij het sluiten.</p>
<p>Bitcoin heeft veel voordelen, zoals grensoverschrijdend, gemakkelijk en efficiënt zijn, en is niet onderhevig aan menselijke manipulatie. Het wordt altijd beschouwd als digitaal goud en heeft een afdekkend effect. Bijvoorbeeld, Mike Mc Glone, een senior macrostrateeg bij Bloomberg, vermeldde in een tweet dat <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> na het conflict tussen Israël en Hamas een trend van afdekking heeft laten zien.</p>
<p>De impact van de oorlog op cryptocurrencies lijkt echter niet lineair te worden overgedragen vanuit historische gegevens en er zijn nog veel details die verder moeten worden onderzocht.</p>
<h2 id="h2-De20prestaties20van20de20Cryptomarkt20in20de20oorlog153209"><a name="De prestaties van de Crypto-markt in de oorlog" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De prestaties van de Crypto-markt in de oorlog</h2><p>In feite, bij terugblik op het verleden van het conflict tussen Rusland en Oekraïne en het huidige conflict tussen Israël en Palestina, toont Bitcoin geen significante risico-aversie.</p>
<p>Zoals te zien is in de onderstaande afbeelding, brak het conflict tussen Rusland en Oekraïne uit op 24 februari 2022, met respectievelijk stijgingen van 2,89%, 2,34%, -0,28% en -3,59% op dezelfde dag en in de daaropvolgende dagen; Het grootschalige gewapende conflict tussen Palestina en Israël brak uit op 7 oktober 2023, met respectievelijk winsten van 0,09%, -0,13% en -1,18% op die dag en de daaropvolgende dagen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169691962210651696919570_.pic.jpg" alt=""><br>BTC Wekelijkse Grafiek 1 Bron: Gate.io</p>
<p>Uit de dagelijkse stijging van de muntprijzen kan worden geconcludeerd dat de schommelingen in Bitcoin normaal zijn en geen significante schommelingen in deze lokale oorlogen hebben veroorzaakt.</p>
<p>Het verkennen van oorlog heeft echter wel een leidende betekenis voor crypto-investeringen, aangezien de twee dichtstbijzijnde conflicten voor de markt beide gelokaliseerd en relatief controleerbaar zijn op schaal. Zodra er een grootschalige oorlog uitbreekt buiten de regionale omvang, zal dit de reactie van de cryptomarkt aanzienlijk testen. Daarom moeten we nog steeds letten op de daaropvolgende veranderingen in de oorlog.</p>
<p>Bijvoorbeeld COVID-19, dat uitbrak in december 2019, had aanvankelijk geen invloed op de financiële markt, maar met de geleidelijke verspreiding van de epidemie, daalde de wereldwijde financiële markt, inclusief Bitcoin, uiteindelijk aanzienlijk in maart, wat kan worden gezegd als het resultaat van de opbouw van paniek onder investeerders.</p>
<p>Bovendien zal oorlog de meest directe impact hebben op het cryptoproject van het strijdbare concept.</p>
<p>Bijvoorbeeld, het conflict tussen Rusland en Oekraïne leidde tot een stijging van 600% in WAVES. <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Golven</a> was het grootste openbare ketenproject in Rusland op dat moment. De belangrijkste waarde was het vereenvoudigen van grensoverschrijdende transacties, wat precies overeenkwam met de vraag van mensen naar grensoverschrijdende vermogensoverdracht onder invloed van de oorlog.</p>
<p>Onder de schaduw van het Israëlisch-Palestijns conflict steeg de BNT-token van het DEX-protocol Bancor gisteren met 50%, terwijl COTI, een ander belangrijk betalingsplatform, ook een bijna 20% stijging op dezelfde dag zag. Bancor was de eerste gedecentraliseerde uitwisseling die Automated Market Maker (AMM) liquiditeitspools gebruikte, opgericht door een groep Israëli’s in 2016, met zijn operationeel centrum in Tel Aviv.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169691966210661696919590_.pic.jpg" alt=""><br>BNT Dagelijkse Grafiek 2 Bron: Gate.io</p>
<p>Het is vermeldenswaard dat de aanzienlijke stijging van tokens WAVES, BNT en COTI die hierboven zijn genoemd, allemaal verband houden met digitale betalingen. Israël, als technologische grootmacht, heeft een sterke positie in het crypto-veld. Andere conceptvaluta’s die aanzienlijk afwijken van betalingen of handel, zoals SSV, SCRT, BNT, CHR, POOLZ, KAS, enz., hebben echter geen significante stijgingen doorgemaakt, maar hebben in plaats daarvan een daling ondergaan.</p>
<h2 id="h2-Wat20is20de20toekomstige20prijs20van20Bitcoin32655"><a name="Wat is de toekomstige prijs van Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de toekomstige prijs van Bitcoin</h2><p>Sinds het uitbreken van het Israëlisch-Palestijnse conflict heeft Bitcoin geen significante stijging gezien om zijn veilige haven karakter te benadrukken, en handhaaft nog steeds een volatiel aanpassingstrend in het bereik van $25.000 - $28.000, met een sterkere trend dan Altcoin. Natuurlijk is deze kracht niet te wijten aan de hedgevraag die wordt veroorzaakt door de oorlog, maar eerder aan de relatief sterke staat die sinds het begin van dit jaar is gehandhaafd.<br><img src="https://gimg2.gateimg.com/image/article/169691968910671696919603_.pic.jpg" alt=""><br>BTC Dagelijkse Grafiek 3 Bron: Gate.io</p>
<p>Op dit moment ligt de focus van de markt nog steeds op drie dingen met betrekking tot BTC: het halveringsevenement van volgend jaar, de beoordeling van spot ETF’s door de SEC en de verwachte renteverlaging door de Federal Reserve volgend jaar.</p>
<p>Het effect van oorlog op de financiële markt is complex en voortdurend veranderend. Naarmate Bitcoin blijft doordringen in het mainstream-consensus, zal dit effect blijven overlappen met de cryptomarkt. Daarom is het, hoewel het effect op crypto-activa op korte termijn beperkt is, nog steeds noodzakelijk dat investeerders met gediversifieerde portefeuilleactiva aandacht besteden aan het verloop van de oorlog en de gevolgen ervan.</p>
<p>We moeten nog steeds nauwlettend in de gaten houden of de plotselinge uitbraak van het Israëlisch-Palestijnse conflict in oktober een verdere impact zal hebben op de wereldwijde situatie en het rentebeleid van de Federal Reserve, en of de omvang van de oorlog, als deze blijft uitbreiden, mogelijk een aanzienlijke impact kan hebben op de cryptomarkt die anders is dan gebruikelijk.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Peter L.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips">*Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br><div>*Gate.io behoudt alle rechten op dit artikel. Het reposting van het artikel zal worden toegestaan, mits Gate.io wordt genoemd. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div>

<p></p><p></p><div class="blog-details-info"><br>  <div>Auteur:<strong>Peter L.</strong>, Gate.io researcher<p></p>
<div class="info-tips"><em>Deze tekst vertegenwoordigt alleen de mening van de auteur en vormt geen enkel handelsadvies.<br>  </em><div><em></em> Dit artikel is origineel en is eigendom van Gate.io. Als u het wilt reproduceren, dient u de auteur en de bron te vermelden. Anders wordt er juridische stappen ondernomen.<br></div><p></p><br></div></div></div></div></div></div></div>