Tm90aXppZSBxdW90aWRpYW5lIHwgTGEgcXVvdGEgZGkgbWVyY2F0byBkaSBCVEMgaGEgcmFnZ2l1bnRvIHVuIG51b3ZvIG1hc3NpbW8gbmVnbGkgdWx0aW1pIGFubmk7IEZvY2FsaXp6YXRpIHN1bGxvIHNibG9jY28gZGVpIHByaW1pIDYgdG9rZW4gcXVlc3RhIHNldHRpbWFuYSwgZGF0aSBkaSBncmFuZGUgcGVzbyBzYXJhbm5vIHJpbGF

2023-10-23, 05:28

<p><img src="https://gimg2.gateimg.com/image/article/16980411421023.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20quota20di20mercato20di20Bitcoin20ha20raggiunto20un20nuovo20massimo20negli20ultimi20anni20Focalizzati20sullo20sblocco20delle20prime20620token20questa20settimana340977"><a name="Crypto Daily Digest: La quota di mercato di Bitcoin ha raggiunto un nuovo massimo negli ultimi anni; Focalizzati sullo sblocco delle prime 6 token questa settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La quota di mercato di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ha raggiunto un nuovo massimo negli ultimi anni; Focalizzati sullo sblocco delle prime 6 token questa settimana</h2><p>Secondo i dati di Coineck, la quota di mercato di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> è aumentato oltre al 49%, raggiungendo il punto più alto da oltre due anni. La posizione dominante di Bitcoin è aumentata costantemente, passando da circa il 38% all’inizio di quest’anno al 48,85% il 21 ottobre, raggiungendo il livello più alto da aprile 2021. Questo aumento di dominanza può essere attribuito ad un rimbalzo di un anno nei prezzi di Bitcoin, che sono aumentati dell’81% dall’inizio dell’anno.</p>
<p>Secondo i dati di CoinGecko, la quota di mercato di Bitcoin è salita a un nuovo massimo da aprile 2021, temporaneamente al 49,85%; <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La quota di mercato di ‘s è temporaneamente segnalata al 16,6%; La quota di mercato di USDT riporta temporaneamente il 7,22%.</p>
<p>Rebecca Stevens, una ricercatrice presso The Block, ha sottolineato che l’aumento della dominanza riflette che le criptovalute ‘sono rimaste forti nelle attuali condizioni di mercato e si sono comportate bene per la maggior parte di questa settimana. Il dilemma dell’inflazione, i rischi geopolitici e il sempre più partigiano governo degli Stati Uniti hanno messo sotto pressione gli investitori che cercano di ridurre al minimo i rischi’.</p>
<p>Nel frattempo, Bitcoin sembra essere più vicino che mai all’approvazione dello spot ETF e può in un certo senso fungere da protezione ideologica contro l’incertezza sulla scena mondiale, aiutandolo a riconquistare una posizione più dominante nel campo delle criptovalute.</p>
<p>Il fondatore di SlowMist, Cos, ha pubblicato sui social media che la Lightning Network ha subito un attacco di loop di sostituzione, simile all’attacco sandwich in MEV, che utilizza sandwich frontali e posteriori per intrappolare i fondi dal target. Implementare questo metodo di attacco non è facile e devono essere soddisfatte le seguenti condizioni: aprire due canali sulla vittima. Il pagamento viene instradato attraverso uno di questi due canali.</p>
<p>Gli HTLC-timeouts delle vittime dell’attacco a loop di sostituzione sono entro i blocchi Δ. Nel frattempo, è necessario garantire che le vittime non scoprano le transazioni delle immagini precedenti HTLC. Prima che questo rischio sia risolto, i team di progetto che utilizzano reti lightning possono essere vigili prima di stabilire canali a monte e a valle. È meglio stabilire una rete affidabile per ridurre il rischio di essere scoperti, e ulteriori test e verifiche sono necessari per situazioni specifiche.</p>
<p>Secondo i dati di Token Unlocks, questa settimana sei progetti subiranno lo sblocco token one-time, con un valore totale di rilascio superiore a $8 milioni. Tra di essi, YGG e CTSI riceveranno uno sblocco one-time di grandi dimensioni.</p>
<p>Alle 4:00 (UTC) del 23 ottobre, Cartesi sblocca 21,43 milioni di CTSI, del valore di circa $2,8 milioni, pari al 2,91% dell’offerta circolante;</p>
<p>Alle 2:00 (UTC) del 24 ottobre, <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> Il primo lotto di Crowdloans sbloccherà circa 100 milioni di DOT, del valore approssimativo di 396 milioni di dollari;</p>
<p>Alle 2:00 (UTC) del 26 ottobre, Euler (EUL) sblocca circa 145.000 token del valore di circa 390.000 dollari;</p>
<p>Alle 0:00 (UTC) del 27 ottobre, Galxe sbloccherà 586000 GALs, del valore approssimativo di $686.000, pari al 1,26% dell’offerta circolante;</p>
<p>Alle 14:00 (UTC) del 27 ottobre, Yield Guild Games sblocca 12,58 milioni di YGG, del valore approssimativo di $2,95 milioni, corrispondenti al 6,8% dell’offerta in circolazione;</p>
<p>Alle 0:00 (UTC) del 28 ottobre, SingularityNET sbloccherà 9,53 milioni di AGIX, del valore approssimativo di $1,74 milioni, corrispondenti al 0,77% dell’offerta circolante.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi23155"><a name="Tendenze principali dei token di oggi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze principali dei token di oggi</h2><h3 id="h3-BTC97122"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><img src="https://gimg2.gateimg.com/image/article/1698041175BTC.png" alt=""><br>Questa settimana, Bitcoin ha registrato una svolta sopra la resistenza di $30.000, con un supporto a breve termine che si sta gradualmente alzando come una linea di svolta. Fai attenzione a vedere se continua a salire sopra il livello di $30.888. La tendenza generale si avvicina ad un punto di svolta alla fine del trimestre, che viene considerato un segnale per un potenziale inversione sia nelle posizioni corte che lunghe. Si consiglia di mantenere il supporto al livello di $29.495.</p>
<p>Se il grafico giornaliero riesce a rompere con successo il livello di $30.888, lo scenario a breve termine potrebbe vedere un retest di $30.600. Inoltre, c’è stata la completamento di un significativo modello rialzista a doppio minimo “W” dall’inizio di quest’anno, e il prezzo potrebbe continuare a salire verso i livelli di resistenza di $33.000 e $36.000.</p>
<p>Al contrario, se il livello di resistenza di $30.888 aumenta ma non viene superato o si verifica una falsa rottura e si ritira rapidamente, la tendenza di quest’anno potrebbe assistere alla formazione di un significativo pattern di testa e spalle. Per una strategia di vendita conservativa, considera di posizionare ordini di resistenza al di sotto del livello di $30.800 e prevedi che il prezzo potrebbe scendere potenzialmente al livello di supporto di $28.100.</p>
<h3 id="h3-ETH856091"><a name="ETH" class="reference-link"></a><span class="header-link octicon octicon-link"></span>ETH</h3><p><img src="https://gimg2.gateimg.com/image/article/1698041199ETH.png" alt=""><br>Questa settimana, insieme al mercato più ampio, <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha raggiunto un punto di resistenza a $1.694. A breve termine, si consiglia di osservare la linea di tendenza discendente rossa. Se il prezzo rimane al di sotto della resistenza rossa e del livello di $1.726, esso ricade ancora nella tendenza ribassista. Il volume di trading a breve termine sembra relativamente debole rispetto all’intero mercato, e il focus a breve termine potrebbe non essere su Ethereum.</p>
<h3 id="h3-LINK2127"><a name="LINK" class="reference-link"></a><span class="header-link octicon octicon-link"></span>LINK</h3><p><img src="https://gimg2.gateimg.com/image/article/1698041218LINK.png" alt=""><br>Guidando il settore degli oracoli, Chainlink ha visto delle posizioni strategiche nell’intervallo di prezzo tra $4.75 e $8.35. L’attuale profitto è del 84.95%, ed è consigliabile continuare con una strategia di hold a lungo termine. Nel breve termine, è possibile un ritracciamento verso la fascia superiore di $9.45. Se si opera a breve termine, considerare di prendere i profitti, mentre la prospettiva a lungo termine continua a mirare ai massimi storici.</p>
<h2 id="h2-Macro20la20Federal20Reserve2020in20un20periodo20di20silenzio20concentrandosi20sul20rilascio20dei20dati20di20questa20settimana773402"><a name="Macro: la Federal Reserve è in un periodo di silenzio, concentrandosi sul rilascio dei dati di questa settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: la Federal Reserve è in un periodo di silenzio, concentrandosi sul rilascio dei dati di questa settimana</h2><p>La Federal Reserve ritiene che la Fed non abbasserà i tassi di interesse fino a metà dell’anno prossimo. La fine del 2024 potrebbe essere il momento in cui la Federal Reserve taglierà i tassi di interesse. Rapporto semestrale sulla stabilità finanziaria della Federal Reserve: L’inflazione continua potrebbe comportare rischi finanziari.</p>
<p>I funzionari della Federal Reserve sono entrati in un periodo di silenzio questa settimana e non ci saranno molte notizie dal mercato. Tuttavia, sulla base dell’ultima infiltrazione di informazioni da parte dei funzionari della Federal Reserve, è generalmente possibile dire addio alle rialzi dei tassi di interesse a novembre. Come abbiamo già detto in precedenza, questa fase di rialzi dei tassi di interesse è essenzialmente terminata, ma la Federal Reserve sta ancora osservando la forza dei dati per continuare a monitorare.</p>
<p>Nel frattempo, per quanto riguarda il taglio dei tassi di interesse dell’anno prossimo, sebbene Bostek abbia detto che non ci sarà alcun taglio dei tassi di interesse fino a metà 2024, non dovremmo credere troppo perché questo ritmo cambierà con la macroeconomia e i dati, piuttosto che essere statico. Pertanto, ritengo che il taglio dei tassi di interesse arriverà sicuramente presto, altrimenti l’economia statunitense esperimenterà inevitabilmente una significativa recessione.</p>
<p>Secondo i dati di “Osservazione della Federal Reserve” del CME, la probabilità che la Federal Reserve mantenga i tassi di interesse al 5,25% -5,50% a novembre è del 99,9%, e la probabilità di un taglio dei tassi di 25 punti base al 5,00% -5,25% è dello 0,1%.</p>
<p>Questa settimana ci concentreremo sui dati. Martedì sera alle 13:45 (UTC), verranno rilasciati i dati PMI, con un PMI manifatturiero di 49,8 e una lettura prevista di 49,5; Il valore pre-PMI del settore dei servizi è 50,1, con una previsione di 49,4; Il PMI del settore manifatturiero e dei servizi è il primo dato di peso rilasciato nella prossima settimana, e il mercato si aspetta che il valore iniziale del PMI del settore dei servizi Markit negli Stati Uniti a ottobre scenda al di sotto della “linea di boom e busta”.</p>
<p>In tal caso, c’è la possibilità di un calo significativo dell’indice del dollaro USA quel giorno (testando il livello di 105,00). Molti analisti sono alla ricerca di un punto di svolta nei dati economici statunitensi che sia passato da un boom all’altro.</p>
<p>Alle 12:30 (UTC) di giovedì, i dati sul PIL degli Stati Uniti per il terzo trimestre sono stati rilasciati, con un valore precedente del 2,1% e una previsione del 4,1%; il PIL degli Stati Uniti di giovedì potrebbe causare una sensazione sul mercato, con l’aspettativa che il PIL degli Stati Uniti nel terzo trimestre salirà a un livello di fino al 4,1%, raddoppiando direttamente.</p>
<p>Alle 12:30 (UTC) di venerdì è stato annunciato il tasso annuale dell’indice dei prezzi core PCE degli Stati Uniti per settembre, con un valore precedente del 3,9% e una previsione del 3,7%. Venerdì verrà rilasciato l’indicatore di inflazione preferito dalla Federal Reserve, che dovrebbe mostrare ostinazione e persistenza nell’inflazione, il che potrebbe aumentare le aspettative di mercato per l’aumento dei tassi di interesse della Fed.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>