TCdpbXBhdHRvIGRlbCBjb25mbGl0dG8gaXNyYWVsby1wYWxlc3RpbmVzZSBzdWwgbWVyY2F0byBkZWxsZSBjcmlwdG92YWx1dGU=

2023-10-10, 06:35

<p><img src="https://gimg2.gateimg.com/image/article/1690791857hotspot.jpeg" alt=""></p>
<h2 id="h2-TLDR758432"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>La guerra colpisce in primo luogo l’economia reale e il mercato azionario, soprattutto in settori come l’energia, l’esercito, l’aviazione e i trasporti.</p>
<p>In retrospettiva del conflitto passato tra Russia e Ucraina e del conflitto attuale tra Israele e Palestina, <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> non mostra una significativa avversione al rischio.</p>
<p>Alcune valute concettuali legate ai pagamenti digitali in paesi belligeranti potrebbero beneficiare di un aumento.</p>
<h2 id="h2-Introduzione318806"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Dal 7 ottobre, è scoppiato un conflitto armato su larga scala tra l’organizzazione palestinese Hamas e Israele. Mentre la situazione di guerra continua a scalare, anche i mercati finanziari hanno risposto di conseguenza. Questo articolo prenderà il conflitto israelo-palestinese come esempio per esplorare l’impatto della guerra sul mercato delle criptovalute.</p>
<h2 id="h2-Limpatto20del20conflitto20israelopalestinese20sul20mercato184130"><a name="L’impatto del conflitto israelo-palestinese sul mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>L’impatto del conflitto israelo-palestinese sul mercato</h2><p>Dal 7 ottobre, Israele è entrato in uno stato di guerra con l’organizzazione radicale palestinese Hamas, causando migliaia di vittime e diffondendo le fiamme della guerra anche nei paesi vicini. Il Libano e altri hanno dichiarato guerra per unirsi alla mischia. Il presidente degli Stati Uniti Biden, che ha sempre sostenuto Israele, ha successivamente annunciato che continuerà a sostenere Israele.</p>
<p>Questo conflitto è ancora in corso, e sebbene discutere l’effetto della guerra sui nostri investitori potrebbe non essere tempestivo, noi apprezziamo altamente e speriamo per la pace. Tuttavia, è anche necessario utilizzare questo evento per fare chiarezza sull’impatto sul mercato, in modo da poter avere una visione più acuta e completa del mondo e del mercato, e apprezzare il miglioramento complessivo del valore della società portato da un ambiente pacifico.</p>
<p>In generale, una volta che scoppia una guerra, l’economia reale viene colpita per prima, che è la comprensione di base della guerra. La stagnazione della produzione aziendale e dell’economia ha causato un grande impatto sulla produzione e sulla vita delle persone.</p>
<p>L’impatto della guerra sui mercati finanziari di solito colpisce prima il mercato azionario e attira l’attenzione delle persone sui fondi rifugio. Prendendo il conflitto attuale israelo-palestinese come esempio, i settori dell’energia e militare hanno guidato i guadagni, mentre le azioni dell’aviazione hanno sofferto. A causa della sospensione delle rotte israeliane da parte di diverse compagnie aeree, le azioni delle compagnie aeree sono generalmente crollate, con United Airlines, Delta Airlines e American Airlines che hanno perso più del 4% ieri. In confronto, il fornitore israeliano di soluzioni di sicurezza per droni ParaZero è schizzato del 132%.</p>
<p>Nel frattempo, il conflitto israelo-palestinese ha scatenato un sentimento di avversione al rischio, con i prezzi dell’oro in aumento del 1,04%. Inoltre, anche se né la Palestina né Israele producono petrolio, la zona di conflitto è l’area di trasporto per il petrolio greggio del Medio Oriente, il che influirà anche sull’offerta di petrolio greggio. Alla fine della giornata di trading, il petrolio americano è salito del 4,34% e il petrolio Brent è salito del 4,22%.</p>
<p>Vale la pena menzionare il mercato azionario israeliano. Dopo l’esplosione del conflitto, l’ETF israeliano è sceso di oltre il 7%, segnando il suo più grande declino dal marzo 2020. Dopo una brusca caduta di oltre il 6% domenica, il mercato azionario israeliano ha continuato ad aprire al ribasso lunedì, con una caduta di oltre l’1% durante la sessione. Tuttavia, come annunciato dalla Banca di Israele in sessione, che investirà in liquidità per alleviare la volatilità del tasso di cambio dello shekel (fiat israeliana), il mercato azionario israeliano ha successivamente smesso di cadere e si è invertito, chiudendo in rialzo di quasi l’1%.</p>
<p>Bitcoin ha molti vantaggi come essere transfrontaliero, conveniente ed efficiente, e non è soggetto a manipolazioni umane. È sempre stato considerato oro digitale e ha un effetto di copertura. Ad esempio, Mike Mc Glone, un macro stratega senior presso Bloomberg, ha menzionato in un tweet che dopo il conflitto tra Israele e Hamas, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ha mostrato una tendenza di copertura.</p>
<p>Tuttavia, l’impatto della guerra sulle criptovalute non sembra essere trasmesso linearmente dai dati storici, e ci sono ancora molti dettagli che devono essere ulteriormente esplorati.</p>
<h2 id="h2-La20performance20del20mercato20cripto20nella20guerra179071"><a name="La performance del mercato cripto nella guerra" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La performance del mercato cripto nella guerra</h2><p>In realtà, in retrospect del passato conflitto Russia-Ucraina e dell’attuale conflitto israelo-palestinese, Bitcoin non mostra una significativa avversione al rischio.</p>
<p>Come mostrato nella figura sottostante, il conflitto Russia-Ucraina è scoppiato il 24 febbraio 2022, con aumenti rispettivamente del 2,89%, 2,34%, -0,28% e -3,59% lo stesso giorno e nei giorni successivi; Il conflitto armato su larga scala tra Palestina e Israele è scoppiato il 7 ottobre 2023, con guadagni rispettivamente dello 0,09%, -0,13% e -1,18% in quel giorno e nei giorni successivi.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169691962210651696919570_.pic.jpg" alt=""><br>Grafico settimanale BTC 1 Fonte: Gate.io</p>
<p>Dall’aumento giornaliero dei prezzi delle monete, si può concludere che le fluttuazioni del Bitcoin sono normali e non hanno causato significative fluttuazioni in queste guerre locali.</p>
<p>Tuttavia, esplorare la guerra non è privo di significato guida per gli investimenti in criptovaluta, poiché i due conflitti più vicini al mercato sono entrambi localizzati e relativamente controllabili nella scala. Una volta che scoppia una guerra su larga scala al di là del campo regionale, metterà fortemente alla prova la risposta del mercato delle criptovalute. Pertanto, dobbiamo comunque prestare attenzione alle successive modifiche nella guerra.</p>
<p>Ad esempio, il COVID-19, che è scoppiato nel dicembre 2019, non ha avuto un impatto sul mercato finanziario all’inizio, ma con la graduale diffusione dell’epidemia, il mercato finanziario globale, compreso Bitcoin, è infine crollato significativamente nel marzo, il che può essere considerato il risultato dell’accumulo di panico tra gli investitori.</p>
<p>Inoltre, la guerra avrà l’impatto più diretto sul progetto crypto del concetto bellicoso.</p>
<p>Ad esempio, il conflitto Russia-Ucraina ha portato ad un aumento del 600% di WAVES. <a href="/price/waves-waves" rel="nofollow noopener noreferrer" target="_blank">Onde</a> era il progetto di catena pubblica più grande in Russia al momento. Il suo valore principale era semplificare le transazioni transfrontaliere, che corrispondevano alla domanda delle persone per il trasferimento di asset transfrontalieri sotto l’effetto della guerra.</p>
<p>All’ombra del conflitto israelo-palestinese, i token BNT del protocollo DEX Bancor sono aumentati del 50% ieri, mentre COTI, un’altra importante piattaforma di pagamento, ha registrato un incremento del quasi 20% nello stesso giorno. Bancor è stata la prima borsa decentralizzata a utilizzare i pool di liquidità Automated Market Maker (AMM), fondata da un gruppo di israeliani nel 2016, con sede operativa a Tel Aviv.</p>
<p><img src="https://gimg2.gateimg.com/image/article/169691966210661696919590_.pic.jpg" alt=""><br>Grafico giornaliero BNT 2 Fonte: Gate.io</p>
<p>Vale la pena notare che l’aumento significativo dei token WAVES, BNT e COTI menzionati sopra è tutto legato ai pagamenti digitali. Israele, come potenza tecnologica, ha una posizione forte nel campo delle criptovalute. Tuttavia, altre valute concettuali che si discostano significativamente dagli affari di pagamento o di trading, come SSV, SCRT, BNT, CHR, POOLZ, KAS, ecc., non hanno registrato aumenti significativi, ma hanno invece subito una flessione.</p>
<h2 id="h2-Qual2020il20prezzo20futuro20del20Bitcoin532570"><a name="Qual è il prezzo futuro del Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Qual è il prezzo futuro del Bitcoin</h2><p>Dal momento dell’epidemia del conflitto israelo-palestinese, Bitcoin non ha registrato un aumento significativo che evidenzi la sua natura di rifugio sicuro, e continua a mantenere un trend di aggiustamento volatile nell’intervallo da $25.000 a $28.000, con un trend più forte rispetto alle Altcoin. Naturalmente, questa forza non è dovuta alla domanda di copertura portata dalla guerra, ma piuttosto allo stato relativamente forte che è stato mantenuto dall’inizio di quest’anno.<br><img src="https://gimg2.gateimg.com/image/article/169691968910671696919603_.pic.jpg" alt=""><br>Grafico giornaliero BTC 3 Fonte: Gate.io</p>
<p>Attualmente, l’attenzione del mercato su BTC è ancora incentrata su tre cose: l’evento di dimezzamento dell’anno prossimo, la revisione della SEC degli ETF spot e il taglio previsto dei tassi di interesse della Federal Reserve l’anno prossimo.</p>
<p>L’impatto della guerra sul mercato finanziario è complesso e in continua evoluzione. Poiché Bitcoin continua ad entrare nel consenso generale, questo impatto continuerà ad intersecarsi con il mercato delle criptovalute. Pertanto, anche se l’impatto sugli asset crittografici nel breve termine è limitato, è comunque necessario che gli investitori che hanno asset diversificati nel loro portafoglio prestino attenzione al processo di guerra e al suo impatto.</p>
<p>Dobbiamo ancora osservare attentamente se l’improvviso scoppio del conflitto israelo-palestinese in ottobre avrà un ulteriore impatto sulla situazione globale e sulla politica dei tassi di interesse della Federal Reserve, e se l’entità della guerra, se continua ad espandersi, potrebbe avere un impatto significativo sul mercato delle criptovalute diverso dal solito.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Peter L.</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips">*Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br><div>*Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div>

<p></p><p></p><div class="blog-details-info"><br>  <div>Autore:<strong>Peter L.</strong>, Ricercatore di Gate.io<p></p>
<div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista dell'autore e non costituisce alcun consiglio di trading.<br>  </em><div><em></em> Questo contenuto è originale e il copyright è di proprietà di Gate.io. Se desideri riprodurlo, per favore citane l'autore e la fonte, altrimenti saranno perseguite responsabilità legali.<br></div><p></p><br></div></div></div></div></div></div></div>