RGFpbHkgTmV3cyB8IFVCUyBzdXBwb3J0ZXLDoCBnbGkgRVRGIGNyaXR0b2dyYWZpY2kgY29uZm9ybWk7IExlIGNvbW1pc3Npb25pIGRpIHRyYWRpbmcgQlRDIHNvbm8gYXVtZW50YXRlIGRpIHF1YXNpIGlsIDEwMDAlOyBDTUUgZGl2ZW50YSBpbCBwacO5IGdyYW5kZSBzY2FtYmlvIHBlciBnbGkgaW50ZXJlc3NpIGFwZXJ0aSBkZWkgZnV

2023-11-10, 06:11

<p><img src="https://gimg2.gateimg.com/image/article/16995968411_10.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20UBS20supporter20gli20ETF20crittografici20conformi20le20commissioni20di20trading20di20Bitcoin20sono20aumentate20di20quasi20il201000592584"><a name="Riepilogo giornaliero delle criptovalute: UBS supporterà gli ETF crittografici conformi; le commissioni di trading di Bitcoin sono aumentate di quasi il 1000%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: UBS supporterà gli ETF crittografici conformi; le commissioni di trading di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> sono aumentate di quasi il 1000%</h2><p>Secondo Bloomberg, nel processo di promuovere la costruzione di un centro di asset digitali a Hong Kong, UBS Group, insieme a concorrenti come HSBC Holdings, ha permesso ai clienti di Hong Kong di negoziare alcuni fondi negoziati in borsa collegati alle criptovalute.</p>
<p>Secondo fonti interne, a partire da venerdì, i clienti facoltosi potranno acquistare tre ETF crittografici autorizzati dalla Commissione di regolamentazione dei titoli di Hong Kong sulla piattaforma UBS Hong Kong, tra cui Samsung. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Futures attivi, ETF Futures Bitcoin CSOP e ETF Futures Ether CSOP. I clienti possono anche accedere a materiali educativi per comprendere i rischi.</p>
<p>Quando i Futures del Bitcoin CSOP e i Futures dell’Ether CSOP sono stati lanciati lo scorso dicembre, sono stati acclamati come i primi Bitcoin e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> ETF futures quotati in Asia. Gli asset totali di questi due fondi e dei veicoli di investimento di Samsung sono relativamente piccoli, pari a circa 70 milioni di dollari.</p>
<p>Da agosto, le commissioni di transazione per Bitcoin sono aumentate di quasi il 1000%.</p>
<p>I dati mostrano che la commissione media di transazione per la blockchain di Bitcoin ha raggiunto $6,84, un aumento di circa il 970% rispetto al minimo di $0,64 toccato ad agosto. La società di gestione degli asset digitali 21Shares ha sottolineato in un rapporto mercoledì che questo aumento è stato determinato da un aumento del volume di registrazione degli ordinali, con quasi 1,9 milioni di iscrizioni caricate sulla blockchain nelle ultime due settimane.</p>
<p>Inoltre, secondo i dati di CryptoSlam, nelle ultime 24 ore, dopo aver escluso le transazioni pulite, Bitcoin ha superato <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> diventando la blockchain con le vendite NFT più alte.</p>
<p>In risposta, gli analisti di 21Shares hanno osservato che, sebbene gli Ordinals vengano attualmente utilizzati solo per alcune Meme coins, essi fungono da proxy per la crescente domanda di spazio dei blocchi di Bitcoin, che è particolarmente importante per i minatori. La ripresa degli Ordinals ha anche contribuito alla redditività dei minatori di Bitcoin, con i costi delle transazioni blockchain che attualmente rappresentano circa l’8,5% del loro fatturato.</p>
<p>Secondo i dati di Deribit, contratti opzione BTC con un valore nominale superiore a $1.179 miliardi e contratti opzione ETH con un valore nominale superiore a $400 milioni scadranno per la consegna venerdì (10 novembre). Il prezzo del punto di massimo dolore per BTC è $34.000; Il prezzo del punto di massimo dolore per ETH è $1.700.</p>
<p>Greeks.live ha dichiarato che questa settimana le principali criptovalute hanno raggiunto nuovi massimi, con BTC che è salito a $37.000, determinando un significativo aumento del IV a termine pieno. Attualmente, il Dvol di BTC è alto fino al 65%, e il Dvol di ETH è anch’esso alto fino al 60%, entrambi creando nuovi massimi a breve termine. Il sentimento di mercato è alto, e l’atmosfera rialzista è forte.</p>
<p>Secondo i dati di Coinclass, il Chicago Mercantile Exchange (CME) ha aumentato i suoi contratti futures di Bitcoin in sospeso a 111.080 BTC (valutati a $4,08 miliardi), superando i 104.100 BTC di Binance (valutati a $3,83 miliardi), diventando così il più grande scambio con contratti futures di Bitcoin in sospeso.</p>
<p>Con l’accelerazione del trading orizzontale di Bitcoin e della rotazione di Altcoin, il sentimento rialzista nel mercato crittografico continua a rafforzarsi.</p>
<p>Nelle ultime due settimane, Bitcoin è rimasto nell’intervallo di $34.000 a $36.000. La consolidazione di due settimane di Bitcoin ha portato le persone a rivolgersi alle Altcoins, in particolare <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>. Anche i trader del CME hanno continuato ad aumentare la loro esposizione al rischio al rialzo, e l’interesse aperto del CME continua a raggiungere nuovi massimi, arrivando a 105.000 BTC (3,7 miliardi di dollari).</p>
<p>L’afflusso settimanale di ETF basati su futures ha registrato anche un aumento significativo, con BITO di ProShares che ha registrato il terzo maggiore afflusso settimanale di Bitcoin dal novembre 2021.</p>
<p>Tuttavia, JPMorgan Chase ha espresso dubbi sulla sostenibilità dell’ultima impennata del mercato delle criptovalute, affermando che ‘il rimbalzo delle criptovalute sembra un po’ eccessivo’. Gli analisti di JPMorgan sostengono che i due principali fattori che sembrano aver portato all’aumento delle criptovalute nell’ultimo mese sono la prospettiva dell’approvazione degli ETF di Bitcoin spot negli Stati Uniti e il fallimento della SEC nei casi legali di Ripple e Grayscale.</p>
<p>Tuttavia, gli analisti sono “scettici” di questi fattori o argomenti. Sono “cauti sul futuro mercato crittografico.”</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi375994"><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-BTC600257"><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/1699597090BTC.png" alt=""><br>La scorsa notte, BTC ha brevemente toccato il livello chiave di $38.000 e ha incontrato il precedente obiettivo suggerito di $37.800 nell’aumento del prezzo. Come previsto, si è verificato un significativo movimento di prezzo, con un range del 6,2%, ed è stato costantemente in fase di ritracciamento. Nel breve termine, ci si aspetta che mantenga la stabilità sopra il range di $35.300 e il trend complessivo rimane rialzista.</p>
<p>Una discussione su come identificare oscillazioni significative dei prezzi: Tipicamente, dopo un prolungato trend al rialzo, se il tasso di divergenza del fondo a breve termine è troppo alto e il movimento dei prezzi diventa troppo rapido, mentre il mercato dei futures vede un aumento contrario delle posizioni, potrebbe indicare un precursore di uno scontro lungo-corto, come visto nella rapida caduta dei prezzi dopo il colpo mirato in questo caso.</p>
<h3 id="h3-ETH799380"><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/1699597111ETH.png" alt=""><br>A causa delle notizie riguardanti iShares Ethereum Trust e altre sei istituzioni che hanno richiesto un ETF, il volume di acquisto del mercato secondario è aumentato. Nel breve termine, il prezzo è salito da $1,845 al livello di resistenza a $2,135, con il prezzo attuale che quasi raggiunge l’obiettivo.</p>
<p>Il grafico giornaliero ha cercato per la terza volta di rompere il livello di resistenza di $2.135 e sta raggiungendo un massimo relativo non visto da un anno e mezzo. Nel breve termine, si consiglia di mantenere la stabilità a $2.037 e è probabile che questo tentativo riesca a superare $2.135 e puntare verso $2.381. Si prevede anche che guidi la rotazione del mercato delle altcoin. La raccomandazione dell’ordine limite è di mantenere la stabilità a $2.045.</p>
<h3 id="h3-RIO949835"><a name="RIO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>RIO</h3><p><img src="https://gimg2.gateimg.com/image/article/1699597129RIO.png" alt=""><br>Il mercato globale degli asset ha guidato il rally. La strategia a lungo termine ha registrato guadagni significativi da un minimo di $0.1075 a oltre quattro volte il prezzo attuale. I massimi di fase sono a $0.4650, $0.6060 e $0.9952, con massimi target a lungo termine a $5.22 e $8.88.</p>
<h2 id="h2-Macro20Molti20funzionari20della20Federal20Reserve20seguono20ancora20la20posizione20falconiana20di20Powell2020ancora20troppo20presto20per20smettere20di20aumentare20i20tassi20di20interesse620635"><a name="Macro: Molti funzionari della Federal Reserve seguono ancora la posizione falconiana di Powell, è ancora troppo presto per smettere di aumentare i tassi di interesse?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Molti funzionari della Federal Reserve seguono ancora la posizione falconiana di Powell, è ancora troppo presto per smettere di aumentare i tassi di interesse?</h2><p>Giovedì, a causa di nuovi segni di debolezza del mercato del lavoro nei dati sulla disoccupazione degli Stati Uniti, l’indice del dollaro americano è sceso al minimo della sessione. Successivamente, spinto dalle osservazioni falchi di Powell, è salito vicino al livello 106 e alla fine ha chiuso in rialzo dello 0,36% a 105,91.</p>
<p>I recenti guadagni dei tre principali indici azionari statunitensi sono giunti al termine a causa della posizione falco di Powell e della vendita fredda dei bond statunitensi a 30 anni. Il Dow ha chiuso in calo del 0,65%, il Nasdaq ha chiuso in calo del 0,94% e l’indice S&amp;P 500 ha chiuso in calo dell’0,8%.</p>
<p>L’asta dei bond statunitensi a 30 anni ha mostrato una scarsa domanda e i rendimenti dei bond statunitensi hanno ripreso la loro tendenza al rialzo. Il rendimento del bond statunitense a 30 anni ha chiuso al 4,772%, mentre il rendimento del bond statunitense a 10 anni ha chiuso al 4,628%; Il rendimento del Tesoro statunitense a due anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, è tornato al 5% al 5,029%.</p>
<p>L’oro spot ha interrotto la sua serie di tre giorni di calo consecutivo, allontanandosi dal suo minimo di quasi tre settimane e superando brevemente la soglia dei $1.960. Alla fine ha chiuso in rialzo dello 0,45% a $1.958,6 l’oncia; l’argento spot è salito dello 0,48% a chiudere a $22,64 l’oncia.</p>
<p>I prezzi internazionali del petrolio hanno oscillato orizzontalmente. Il petrolio greggio WTI ha chiuso quasi invariato a $75,54 al barile, e la differenza di prezzo spot del petrolio greggio WTI si è spostata su un premio futuro per la prima volta da luglio; il petrolio greggio Brent ha brevemente superato quota 81 nella sessione di trading, poi ha cancellato la maggior parte dei guadagni della giornata ed è terminato in rialzo dello 0,23% a $79,87 al barile.</p>
<p>Il presidente della Federal Reserve, Powell, ha tenuto un discorso affermando che, se appropriato, la Federal Reserve non esiterà a stringere ulteriormente la politica monetaria. Dopo il discorso di Powell, i trader dei futures sui tassi di interesse a breve termine negli Stati Uniti hanno posticipato la loro aspettativa del primo taglio dei tassi della Federal Reserve da maggio dell’anno prossimo a giugno.</p>
<p>Il presidente ad interim della Federal Reserve di St. Louis, O’Neill Pace, ha dichiarato: “È troppo presto per escludere la possibilità di ulteriori aumenti dei tassi di interesse da parte della Federal Reserve in questa fase.”</p>
<p>Il presidente della Federal Reserve di Richmond, Barkin, ha dichiarato: ‘Non penso che abbiamo ancora completato il rialzo dei tassi di interesse; La pressione dell’inflazione nel settore dei servizi è ancora in corso.’ Il governatore della Federal Reserve, Bowman, ha ribadito la sua aspettativa che saranno necessari ulteriori aumenti dei tassi di interesse.</p>
<p>Il presidente della Fed di Atlanta, Bostick, ha affermato che la politica potrebbe già essere sufficientemente restrittiva. La Federal Reserve manterrà una posizione di rafforzamento fino a quando il tasso di inflazione non scenderà al 2%.</p>
<p>Il presidente della Fed di Chicago, Gullsby, ha affermato che la Fed dovrà essere vigile rispetto al rischio di superamenti dei tassi di interesse. È ancora troppo presto per discutere se o quando spostare l’attenzione sui tagli dei tassi di interesse.</p>
<p>Le decisioni di aumento dei tassi di interesse degli ufficiali hanno nuovamente suscitato preoccupazioni nel mercato, ma il mercato delle criptovalute non ne è stato influenzato. Attualmente, è una tendenza di mercato indipendente, che corrisponde anche alla nostra precedente previsione di un’esplosione del mercato entro la fine dell’anno. Non dovremmo essere influenzati dalle politiche macroeconomiche, almeno per i prossimi tre mesi.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di Gate.io<br><div>Traduttrice: 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 ripubblicare l'articolo a condizione che venga citato Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>