Tm90aXppZSBxdW90aWRpYW5lIHwgR3JheXNjYWxlIGhhIHZpbnRvIGxhIGNhdXNhLCBCVEMgw6ggc2FsaXRvLCBXdSBKaWhhbiDDqCBjYXV0byBtYSByaWFsemlzdGEgc3VsIG1lcmNhdG8sIGkgZGV0ZW50b3JpIGEgbHVuZ28gdGVybWluZSBjb250aW51YW5vIGFkIGF1bWVudGFyZSBsZSBsb3JvIGRldGVuemlvbmkgZGkgQlRD

2023-08-30, 03:58

<p><img src="https://gimg2.gateimg.com/image/article/16933737010830.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20SEC20potrebbe20rispondere20a20diverse20richieste20di20ETF20Bitcoin20questo20fine20settimana20Wu20Jihan2020cauto20ottimista20su20Bitcoin187654"><a name="Crypto Daily Digest: La SEC potrebbe rispondere a diverse richieste di ETF Bitcoin questo fine settimana, Wu Jihan è cauto ottimista su Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La SEC potrebbe rispondere a diverse richieste di ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> questo fine settimana, Wu Jihan è cauto ottimista su Bitcoin</h2><p>Recentemente, la SEC degli Stati Uniti è stata piuttosto occupata.</p>
<p>Secondo le ultime notizie, la SEC degli Stati Uniti dovrebbe rispondere ai documenti di domanda di ETF Bitcoin presentati da Bitwise, BlackRock, VanEck, WisdomTree e Invesco entro la fine di questa settimana, inclusa la negazione, l’approvazione o il rinvio. La domanda di Bitwise sarà esaminata prima di venerdì, mentre le altre domande saranno esaminate il giorno successivo affinché la SEC possa ponderarle prima del weekend.</p>
<p>È stato riferito che la SEC ha posticipato la richiesta di Bitcoin spot per 21Shares e ARK Investment Management all’inizio di agosto, e in precedenza aveva respinto diverse richieste nell’ultimo decennio.</p>
<p>Ieri, secondo documenti giudiziari statunitensi, la richiesta di riesame di Grayscale è stata approvata e l’ordine della SEC statunitense è stato revocato. Lo scorso anno, Grayscale ha presentato una causa contro la SEC per il suo rifiuto di convertire il suo fondo principale GBTC in ETF Bitcoin spot. Questa sentenza significa che Grayscale ha vinto la causa contro la SEC statunitense.</p>
<p>L’analista ETF di Bloomberg, James Seyfart, ha affermato che ciò non significa che GBTC si convertirà automaticamente in ETF, ma avvicina l’evento (l’approvazione degli ETF spot su Bitcoin) di un passo.</p>
<p>Inoltre, la vittoria di Grayscale sulla SEC ha segnato la sessione di trading più intensa di GBTC in 14 mesi, con quasi 20 milioni di azioni di GBTC che hanno cambiato di mano durante la giornata, raggiungendo il livello più alto dal crollo del mercato delle criptovalute nel giugno 2022. Nel frattempo, il prezzo delle azioni di GBTC è salito dell’18% a quasi $21. Inoltre, Bitcoin ha brevemente superato i $28.000 nelle prime ore di oggi e attualmente si sta scambiando a $27.738,18. Successivamente, ieri sera, il tasso di premio negativo di grayscale GBTC si è ridotto al 17%.</p>
<p>Secondo i dati di Coinsecko, il valore di mercato totale delle criptovalute è di circa 1,14 trilioni di dollari, con un aumento del 4,1% nelle ultime 24 ore. Inoltre, il prezzo attuale di Bitcoin è di 27.549,09 dollari, che rappresenta circa il 47,1% del valore di mercato. Il prezzo di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> è di $1,717.43, corrispondente a circa il 18.1% della capitalizzazione di mercato.</p>
<p>L’impero delle criptovalute di Musk è ancora in corso, e secondo le notizie di ieri, la piattaforma di social media X (Twitter) ha ottenuto le licenze necessarie per i pagamenti e le transazioni in criptovaluta negli Stati Uniti.</p>
<p>Secondo i dati visualizzati da NMLS, la licenza di trasmissione di valuta di Rhode Island è stata approvata il 28 agosto (che è richiesta per fornire servizi relativi agli asset virtuali per conto degli utenti). Ciò consentirà a X di archiviare, trasferire e scambiare asset digitali per la sua vasta base di utenti.</p>
<p>Secondo CoinDesk, Matrixport, una società di servizi finanziari cripto di proprietà di Wu Jihan, è diventata cauta e rialzista su Bitcoin, preferendo acquistare e fermare strettamente le perdite in caso di recenti ribassi dei prezzi.</p>
<p>Markus Thielen, Direttore della Ricerca e Strategia presso Matrixport, ha affermato che i trader di criptovalute possono mantenere posizioni long su Bitcoin e impostare stop loss al di sotto di $25.800. Nella condizione di stop loss rigoroso, acquisteremo di più. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Ci si aspetta che il rendimento dei titoli del Tesoro diminuirà e anche le azioni tecnologiche statunitensi aumenteranno. Ci aspettiamo un calo del 10% entro la fine dell’estate, e abbiamo raggiunto questo obiettivo e implementato metodi appropriati di gestione del rischio, consentendo ai trader di provare a tornare long.</p>
<p>Secondo i rapporti di ricerca, nonostante le recenti fluttuazioni di miliardi di dollari in Bitcoin, i detentori a lungo termine di Bitcoin (BTC) continuano ad aumentare il proprio portafoglio. Questi detentori a lungo termine mantengono saldamente le proprie posizioni, evitando transazioni dirette che potrebbero utilizzare Bitcoin come garanzia.</p>
<p>I dati mostrano che i detentori a lungo termine continuano ad aumentare le loro detenzioni di Bitcoin, con il 40% dei detentori che rimane invariato per più di tre anni, raggiungendo un massimo storico.</p>
<p>Osservando attentamente le variazioni di posizione nette dei detentori a lungo termine, si è verificata una tendenza all’accumulo dal marzo 2023. Questo comportamento indica <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> e la potenziale resilienza in caso di volatilità di mercato. Tuttavia, sebbene i detentori che hanno posseduto Bitcoin per più di tre anni continuino ad aumentare le loro posizioni, gli indicatori di offerta inattiva entro un anno mostrano un sentimento più ribassista.</p>
<p>Sebbene i detentori che hanno sperimentato picchi del mercato rialzista e ribassista rimangano fermi, i nuovi detentori che hanno guadagnato posizioni durante il mercato ribassista hanno mostrato più disagio. Resta inteso che questi detentori hanno ritirato le loro posizioni durante il calo dei prezzi di Bitcoin di luglio da un minimo di 29.000$.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi286009"><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-BTC96163"><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/1693373735BTC.png" alt=""><br>La scorsa notte, il mercato complessivo è cresciuto a causa della notizia della vittoria di GrayScale nella causa contro la SEC, superando il livello di $28,1K USD. A breve termine, potrebbe esserci un retest del livello di $26.975 USD. Se il prezzo non si riprende sopra i $29,7K USD, il trend ribassista rimane intatto.</p>
<h3 id="h3-CYBER779014"><a name="CYBER" class="reference-link"></a><span class="header-link octicon octicon-link"></span>CYBER</h3><p><img src="https://gimg2.gateimg.com/image/article/1693373758CYBER.png" alt=""><br>La strategia della scorsa settimana prevedeva l’accumulo passo dopo passo a $4.100 USD, $3.933 USD e $3.783 USD, seguito da uno sviluppo significativo della tendenza. Il target di picco è stato raggiunto esattamente al nostro obiettivo precedentemente fornito di $8.185 USD, con il massimo di ieri che ha raggiunto $8.26 USD, un guadagno sostanziale del 125.15%, in linea con il target della sequenza di Fibonacci.</p>
<p>Colpi mirati così precisi indicano una elevata concentrazione di chip per il market making nelle mani dei market maker. Riuscire a colpire in successione obiettivi di picco accurati suggerisce di completare l’onda rialzista principale. Nel breve termine, osservare se $6,700 USD e $5,875 USD vengono mantenuti come supporto. C’è il potenziale per un’ultima onda rialzista che punta a $17,79 USD. Si consiglia di monitorare nel breve termine utilizzando i livelli di ritracciamento di Fibonacci come punti di uscita.</p>
<h3 id="h3-DOGE459319"><a name="DOGE" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DOGE</h3><p><img src="https://gimg2.gateimg.com/image/article/1693373774DOGE.png" alt=""><br>Il grafico giornaliero complessivo è stato in trend al ribasso per 835 giorni. Potrebbe verificarsi uno sviluppo significativo del trend prima della fine dell’anno. Mantenendo salda la base di prezzo di $0.05099 USD, c’è la possibilità di un trend indipendente verso l’alto verso $0.10799 USD, $0.15879 USD, $0.43360 USD e massimi storici.</p>
<h2 id="h2-Macro20I20dati20statunitensi20deludono20le20aspettative20portando20giganti20come20Buffett20a20essere20pessimisti20sul20mercato138766"><a name="Macro: I dati statunitensi deludono le aspettative, portando giganti come Buffett a essere pessimisti sul mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I dati statunitensi deludono le aspettative, portando giganti come Buffett a essere pessimisti sul mercato</h2><p>La serie di dati economici degli Stati Uniti pubblicati martedì sera sono stati tutti inferiori alle aspettative, e la scommessa del mercato sulla sospensione dei rialzi dei tassi della Federal Reserve a settembre è aumentata. Allo stesso tempo, la probabilità di riprendere i rialzi dei tassi a novembre è diminuita, facendo crollare l’indice del dollaro americano, che ha chiuso in ribasso dello 0,45% a 103,48.</p>
<p>I tre principali indici azionari statunitensi hanno chiuso collettivamente in rialzo, con l’indice Dow Jones in rialzo dello 0,85%, l’indice Nasdaq in rialzo del 1,74% e l’indice S&amp;P 500 in rialzo del 1,49%. Il produttore vietnamita di veicoli elettrici VinFast è crollato del 43%. Gli stock tecnologici statunitensi in generale si sono rafforzati, con Tesla in rialzo del 7,6% e Apple, che sta per lanciare un nuovo telefono, in rialzo di oltre il 2%.</p>
<p>Il numero delle vacanze di lavoro JOLTs negli Stati Uniti a luglio è stato di 8,827 milioni, molto al di sotto delle aspettative di mercato di 9,4-9,5 milioni; La valutazione di mercato è stata anticipata da luglio dell’anno prossimo a giugno, quando la Federal Reserve taglierà i tassi di interesse una volta. Nick Timiraos, anche conosciuto come l’“Agenzia di Notizie della Nuova Federal Reserve”, ha commentato che la Federal Reserve è contenta di vedere questo.</p>
<p>Il rendimento complessivo dei titoli di stato statunitensi è sceso di circa 10 punti base a un nuovo minimo nelle ultime due settimane. Il rendimento dei titoli di stato statunitensi a due anni, sensibile alla politica monetaria, è sceso di 16 punti base rispetto al suo massimo giornaliero, superando i due livelli del 5% e del 4,9%, cancellando tutti i guadagni dal 14 agosto; Il rendimento dei titoli di stato statunitensi a 10 anni è sceso di 14 punti base rispetto al suo massimo giornaliero al 4,12%, cancellando tutti i guadagni dall’11 agosto.</p>
<p>L’oro spot ha beneficiato del indebolimento del dollaro statunitense e dei rendimenti dei titoli di Stato statunitensi, salendo di più di 20 dollari dai minimi intraday e chiudendo in rialzo dello 0,9% a 1.937,43 dollari l’oncia. L’argento spot è salito durante la sessione statunitense, chiudendo in rialzo del 1,95% a 24,7 dollari l’oncia, raggiungendo un nuovo massimo in quasi un mese.</p>
<p>Nel frattempo, il “gigante delle azioni” Warren Buffett e il “prototipo dell’orso grande” Michael Burry sono stati pessimisti sul mercato, e queste informazioni pessimistiche continuano ad influenzare la direzione del mercato finanziario.</p>
<p>Lo senior economist e consulente dell’ex presidente degli Stati Uniti Reagan, Steve Hanke, ha interpretato che il CEO di Berkshire Hathaway e il “grande orso” potrebbero essere in fase di preparazione per i prossimi problemi e prevedendo che l’economia statunitense entrerà in recessione nella prima metà del 2024.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore di 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 ri-pubblicare dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>