Tm90aXppZSBnaW9ybmFsaWVyZSB8IFF1YXNpIDMwSyBCVEMgc29ubyBzdGF0aSB0cmFzZmVyaXRpIGEgQ0VYIHByaW1hIGNoZSBHcmF5c2NhbGUgdmluY2Vzc2UgbGEgY2F1c2EsIGxhIHByb2JhYmlsaXTDoCBjaGUgZ2xpIEVURiBCVEMgc3BvdCB2ZW5nYW5vIGFwcHJvdmF0aSBlbnRybyBpbCAyMDIzIMOoIGFsdGE=

2023-08-31, 04:40

<p><img src="https://gimg2.gateimg.com/image/article/16934566850831.jpg" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Quasi2030K20BTC20sono20stati20trasferiti20a20CEX20prima20che20Grayscale20vincesse20la20causa20e20la20probabilit20che20gli20ETF20spot20di20Bitcoin20vengano20approvati20entro20il2020232020alta711950"><a name="Crypto Daily Digest: Quasi 30K BTC sono stati trasferiti a CEX prima che Grayscale vincesse la causa, e la probabilità che gli ETF spot di Bitcoin vengano approvati entro il 2023 è alta" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Quasi 30K BTC sono stati trasferiti a CEX prima che Grayscale vincesse la causa, e la probabilità che gli ETF spot di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> vengano approvati entro il 2023 è alta</h2><p>Diamo un’occhiata ai progressi relativi alla vittoria di Grayscale.</p>
<p>Secondo i dati di Santiment, quasi 30.000 BTC (per un valore di circa 822 milioni di dollari) sono stati trasferiti a indirizzi relativi a piattaforme di trading centralizzate prima delle sentenze chiave di Grayscale e della SEC. La sentenza ha portato a un’impennata del 6% dei prezzi di Bitcoin, spingendo BTC a 28.000$.</p>
<p>Santiment ha detto: “Prima che Grayscale vincesse la causa, l’offerta di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Le piattaforme di trading sono aumentate significativamente. È chiaro che i dipartimenti competenti sanno che questo risultato aumenterà inevitabilmente il valore di mercato del mercato delle criptovalute.</p>
<p>Precedentemente, i portafogli che detenevano da 100.000 a 10.000 BTC hanno accumulato circa 388 milioni di dollari in BTC il giorno prima della notizia della vittoria di Grayscale. I dati di monitoraggio di Santiment mostrano che gli indirizzi delle balene e degli squali potrebbero essere stati precedentemente informati dei risultati della causa di Grayscale e della SEC. Il giorno prima che questa notizia venisse resa nota, i portafogli che detenevano da 10 a 10.000 BTC hanno accumulato BTC del valore di 388,3 milioni di dollari.</p>
<p>Tuttavia, anche se Grayscale vince la causa, è improbabile che impedisca a Bitcoin di terminare con un rendimento mensile negativo ad agosto. All’inizio di questo mese, il prezzo del BTC era ancora sopra i 29.000 dollari, ma attualmente si aggira sopra i 27.000 dollari. La performance di Bitcoin ad agosto ha portato incertezza al trend di settembre. Volatilità record bassa, volume di scambi in diminuzione e un crollo improvviso nell’intervallo di prezzo di 25000 dollari durante agosto.</p>
<p>James Butterfill, direttore della ricerca di CoinShares, ha dichiarato che il calo dei prezzi ad agosto ha “evidenziato la vulnerabilità del Bitcoin di fronte a transazioni più grandi, situazione che è diventata ancora più grave nell’attuale situazione di basso volume di scambi.”</p>
<p>Butterfill prevede che l’attesa del mercato sarà una caratteristica all’inizio di settembre. Si aspetta che i trader vacillino tra l’entusiasmo per la possibile approvazione delle domande ETF e i dubbi sull’approvazione della SEC. Anche se la decisione della corte di mercoledì favorisce Grayscale, Butterfill ha detto: ‘È improbabile che acceleri i tempi di approvazione della SEC poiché c’è ancora la possibilità di appello’.</p>
<p>L’analista ETF di Bloomberg, James Seyfart, ha twittato: ‘Ci aspettiamo di ricevere un gran numero di ordini ritardati questa settimana. Crediamo che la probabilità di approvazione subito dopo la sentenza del tribunale (ETF Bitcoin spot) sia estremamente bassa.’ Crede anche che gli ETF Bitcoin spot saranno lanciati entro la fine del 2024, il che è quasi certo.</p>
<p>L’analista di Bloomberg Eric Balchunas ha pubblicato oggi, ‘L’analista James Seyfart ed io abbiamo aumentato la probabilità che gli ETF Bitcoin spot vengano lanciati quest’anno al 75% (con una probabilità del 95% entro la fine del 2024).’</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi643771"><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-BTC528243"><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/1693456740BTC 0831.png" alt=""></p>
<p>Nonostante sia stato influenzato dalle notizie di Grayscale questa settimana, ciò ha portato solo a un lieve rimbalzo. Ieri ha raggiunto la neckline a 27.283 dollari statunitensi e poi è nuovamente sceso, indicando che il mercato nel complesso lo considera ancora con una prospettiva ribassista. Si stima che la chiusura mensile sarà intorno ai 26.975 dollari statunitensi.</p>
<h3 id="h3-CYBER184517"><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/1693456755CYBER 0831.png" alt=""></p>
<p>La strategia della settimana scorsa prevedeva posizioni sequenziali a $4.100, $3.933 e $3.783 rispettivamente, seguite da una significativa performance di mercato. Con l’obiettivo di $17,79 indicato dal modello di “sfilare la spada dal fodero” e dal rapido e aggressivo movimento verso l’alto degli operatori di mercato di DWF, non è difficile immaginare che potrebbe esserci un’ultima ondata di performance di mercato a breve termine.</p>
<p>Abbiamo menzionato che avere livelli obiettivi così accurati nel mercato secondario suggerisce che i market maker siano altamente concentrati nelle loro negoziazioni, simile a come operano nel mercato spot e nel mercato dei contratti. CYBER non fa eccezione.</p>
<p>Per posizioni lunghe a breve termine, si consiglia di mantenere stabile il livello di supporto di $8,185, e un approccio conservativo sarebbe attendere un superamento del recente massimo a $8,980 per entrare in posizioni aggiuntive. Quattro livelli di resistenza sono $10,479, $11,883, $13,019 e $14,152. Tre obiettivi ascendenti sono $12,277, $15,62 e l’obiettivo massimo di $17,79.</p>
<h3 id="h3-DOGE296715"><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/1693456774DOGE 0831.png" alt=""></p>
<p>Il trend giornaliero complessivo è stato in un marcato downtrend per 835 giorni e si prevede una significativa performance di mercato entro la fine dell’anno. Mantenendosi stabile al livello di supporto di $0.05099, se si manifesta un trend indipendente, sono previsti obiettivi crescenti sequenziali a $0.10799, $0.15879, $0.43360 e un nuovo massimo storico.</p>
<h2 id="h2-Macro20i20dati20sulloccupazione20e20sul20PIL20inferiore20alle20aspettative20la20Federal20Reserve20potrebbe20non20aumentare20i20tassi20di20interesse20questanno344315"><a name="Macro: i dati sull’occupazione e sul PIL inferiore alle aspettative, la Federal Reserve potrebbe non aumentare i tassi di interesse quest’anno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: i dati sull’occupazione e sul PIL inferiore alle aspettative, la Federal Reserve potrebbe non aumentare i tassi di interesse quest’anno</h2><p>L’oro fisico è salito per tre giorni consecutivi, raggiungendo brevemente quota 1.950 dollari durante la sessione, chiudendo in rialzo dello 0,26% a 1.942,42 dollari l’oncia. L’argento fisico ha brevemente raggiunto quota 25 dollari durante le negoziazioni intraday, segnando la prima volta in oltre un mese. Tuttavia, ha recuperato le sue guadagni intraday e ha chiuso in ribasso dello 0,38% a 24,61 dollari l’oncia. I tre principali indici azionari del mercato azionario statunitense hanno chiuso in rialzo durante la giornata, con il DJIA in rialzo dello 0,11%, il Nasdaq in rialzo dello 0,54% e l’indice S&amp;P 500 in rialzo dello 0,39%.</p>
<p>La scorsa notte, due dati importanti hanno provocato un’intensa reazione di mercato: il numero di posti di lavoro ADP negli Stati Uniti nel mese di luglio è stato molto al di sotto delle aspettative di mercato, in linea con la diminuzione inaspettata delle offerte di lavoro annunciate il giorno precedente, e il mercato del lavoro si sta raffreddando;</p>
<p>Il PIL degli Stati Uniti nel secondo trimestre è stato rivisto al ribasso al 2,1%, inferiore alle aspettative di mercato del 2,4%. I dati economici statunitensi inferiori alle aspettative hanno rafforzato le aspettative degli investitori sulla sospensione dei rialzi dei tassi d’interesse della Federal Reserve.</p>
<p>La Federal Reserve spesso dice “prendere decisioni basate sui dati”, quindi attualmente si trova in una fase di reagire eccessivamente ai dati, che siano buoni, cattivi, importanti o non importanti. Poiché la Federal Reserve fa riferimento a una serie completa di dati, non è sicuramente un modulo dati singolo.</p>
<p>Dopo aver pubblicato i dati sull’occupazione del settore privato e il PIL rivisto del secondo trimestre degli Stati Uniti la scorsa notte, i trader dei futures sui tassi sui fondi federali hanno continuato ad aumentare le aspettative che la Federal Reserve non aumenterà più i tassi di interesse quest’anno.</p>
<p>Secondo lo strumento Fed Watch del Chicago Mercantile Exchange (CME), la probabilità che la Federal Reserve rimanga inattiva a settembre è del 90,5%, superiore all’86% visto un giorno fa. I trader si aspettano che le probabilità di restare fermi a novembre e dicembre siano rispettivamente del 57% e del 55,5%, mantenendo il tasso dei fondi federali nell’intervallo tra il 5,25% e il 5,5%.</p>
<p>L’ex presidente della Fed di Boston ha dichiarato ieri (mercoledì) che se il mercato del lavoro e la crescita economica continuano a rallentare al ritmo attuale, la Fed potrebbe concludere il ciclo di aumento dei tassi di interesse.</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 ripostare l'articolo a condizione che Gate.io venga citato. In tutti i casi, verranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>