RGFpbHkgTmV3cyB8IExhIFNFQyBwb3RyZWJiZSBlc3NlcmUgY29zdHJldHRhIGFkIGFwcHJvdmFyZSBCVEMgU3BvdCBFVEYsIGlsIGRpc2NvcnNvIGRpIFZpdGFsaWsgQnV0ZXJpbiBoYSBzcGludG8gUkFJIGluIHN1IGRpIG9sdHJlIGwnODAlLCBnbGkgaW52ZXN0aXRvcmkgcHVudGFubyBhbGwndW5sb2NraW5nIGRpIDcgdG9rZW4gcXV

2023-09-04, 04:15

<p><img src="https://gimg2.gateimg.com/image/article/16938070720904.jpg" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20la20SEC20potrebbe20essere20costretta20ad20approvare20gli20ETF20spot20di20Bitcoin20il20discorso20di20Vitalik20Buterin20ha20spinto20RAI20al20rialzo20di20oltre20l80115491"><a name="Riassunto giornaliero delle criptovalute: la SEC potrebbe essere costretta ad approvare gli ETF spot di Bitcoin, il discorso di Vitalik Buterin ha spinto RAI al rialzo di oltre l’80%" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: la SEC potrebbe essere costretta ad approvare gli ETF spot di Bitcoin, il discorso di Vitalik Buterin ha spinto RAI al rialzo di oltre l’80%</h2><p>La SEC potrebbe essere costretta ad approvare la richiesta per <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF spot.</p>
<p>Secondo The Block, un rapporto di ricerca degli analisti di JPMorgan guidato da Nikolaos Panigrtzoglou mostra che la recente vittoria di Grayscale suggerisce che la SEC potrebbe essere costretta ad approvare le applicazioni pendenti per i fondi negoziati in borsa di <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> da parte di varie società di gestione patrimoniale, incluso Grayscale.</p>
<p>Gli analisti ritengono che la SEC debba ritirare la sua precedente approvazione per gli ETF basati su future del Bitcoin per giustificare il suo “rifiuto della proposta di Grayscale di convertire il suo fondo fiduciario Bitcoin in un ETF”. Tuttavia, gli analisti hanno aggiunto che questa mossa “è molto imbarazzante e perturbante per gli investitori e sembra improbabile.”</p>
<p>Anche se la SEC ha rinviato tutti gli ETF fino a ottobre, non c’è motivo di rifiutare di passarli a meno che non venga fornita una nuova risoluzione.</p>
<p>Quindi da tutti i punti di vista dell’informazione, l’approvazione è solo una questione di tempo. Se si trova un nuovo motivo per non passare a ottobre di quest’anno, sarà rinviato all’anno prossimo. Pertanto, che sia quest’anno o il prossimo, l’aspettativa di approvazione è sempre stata, e credo che l’approvazione sarà ottenuta al più tardi l’anno prossimo.</p>
<p>In alternativa, influenzato dai commenti di Vitalik, il token Reflexer basato sul protocollo stablecoin di RAI è aumentato di oltre l’80% nelle ultime 24 ore, ed è ora quotato a $13,5. Si comprende che Vitalik Buterin, durante la partecipazione alla discussione su Reflexer Finance su Discord, ha affermato che RAI, come prima stablecoin sulla piattaforma Reflexer, potrebbe diventare un sostenitore attivo dei derivati di liquid staking non popolari (LSDs).</p>
<p>Inoltre, già dall’11 marzo, l’indirizzo contrassegnato Vitalik aveva appena depositato 500 ETH in Reflexer per emettere 150.000 RAIs.</p>
<p>Per quanto riguarda i dati, il volume di scambi spot della Piattaforma di Trading Decentralizzato (DEX) ad agosto ha raggiunto i 22,19 miliardi di dollari, un nuovo minimo dal dicembre 2020 (21,9 miliardi di dollari). Tra questi, la quota di mercato di <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> in agosto è stato del 55,34%, una diminuzione di circa 5 punti percentuali dal 60,55% di luglio.</p>
<p>Il volume di trading spot di CEX ad agosto è stato di $422,95 miliardi, il più basso dallo scorso ottobre (con un volume di trading mensile di $226,58 miliardi). Inoltre, la quota di mercato del trading spot di Binance è diminuita, passando dal 46,88% a luglio al 45,42% ad agosto.</p>
<p>I dati di Token Unlocks mostrano che i token per 7 progetti verranno sbloccati questa settimana, con solo IMX e HFT che superano un milione di dollari. Tra questi:</p>
<p>Alle 3:06 del 4 settembre (UTC), Tornado Cash sbloccherà 22.800 TORN (del valore di circa $61.000), pari a circa l’1,51% del volume di circolazione;</p>
<p>Alle 0:00 (UTC) del 5 settembre, Liquid sbloccherà 657.000 unità LQTY (equivalenti a circa $541.000), pari a circa lo 0,7% del volume circolante;</p>
<p>A mezzogiorno (UTC) del 5 settembre, Galxe sbloccherà 416.000 GAL (del valore approssimativo di $466.000), corrispondenti a circa lo 0,9% del volume circolante;</p>
<p>Alle 19:54 (UTC) del 5 settembre, LooksRare sbloccherà 12,5 milioni di LOOKS (del valore approssimativo di $674.000), pari a circa il 2,29% del volume circolante;</p>
<p>Alle 0:00 am (UTC) del 7 settembre, Hashflow sbloccherà 3,23 milioni di HFT (del valore di circa 1,07 milioni di dollari), pari a circa il 1,84% del volume in circolazione;</p>
<p>Alle 0:00 del 8 settembre (UTC) <a href="/price/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">Moonbeam</a> sbloccherà 3,04 milioni di GLMR (del valore di circa 563.000 dollari), pari a circa lo 0,42% del volume di circolazione;</p>
<p>Alle 22:00 (UTC) del 8 settembre, <a href="/price/immutablex-imx" rel="nofollow noopener noreferrer" target="_blank">ImmutableX</a> sbloccherà 18,08 milioni di IMX (del valore approssimativo di $9,81 milioni), pari a circa l’1,61% della circolazione.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi680492"><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-BTC576469"><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/1693807132BTC.png" alt=""><br>All’inizio del mese, BTC ha subito una diminuzione a $25.333 e si è poi stabilizzato. La struttura a medio termine potenzialmente forma una tendenza a forma di M o un modello a testa e spalle. Se si tratta di una tendenza a forma di M, potrebbe essere considerata una posizione corta quando scende al di sotto del minimo precedente di $25.165, con un obiettivo di $24.222. Se si forma un modello a testa e spalle, potrebbe attirare acquirenti a spingere il prezzo a $30.203, seguito da una rapida diminuzione, potenzialmente segnando la fine dell’alto mercato di quest’anno.</p>
<h3 id="h3-WLD416680"><a name="WLD" class="reference-link"></a><span class="header-link octicon octicon-link"></span>WLD</h3><p><img src="https://gimg2.gateimg.com/image/article/1693807169WLD.png" alt=""><br>A breve termine, WLD sembra mantenere il suo livello di supporto precedentemente identificato a $1.090 e potrebbe sperimentare un rimbalzo secondario. Tuttavia, la struttura a medio termine rimane ribassista. Si consiglia di adottare una strategia di ingresso veloce, uscita veloce per i rimbalzi, con obiettivi al rialzo a $1.142 e $1.193.</p>
<h3 id="h3-CYBER61096"><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/1693807214CYBER.png" alt=""><br>Costruzione di presenza e popolarità online: Il progetto CYBER mirava a generare sufficiente attenzione di mercato e liquidità secondaria lanciandosi su LaunchPool. Questo passaggio era cruciale per attirare l’attenzione sul mercato secondario e gettare le basi per le strategie successive.</p>
<p>Attrarre gli investitori di spot attraverso la volatilità continua: dopo il lancio su CYBER, la volatilità del prezzo è continuata ad allinearsi alla sequenza di Fibonacci, con un prezzo di base stabile di $3,53. Questa fase si è concentrata sulla consolidazione della stabilità di mercato, anche durante le flessioni più ampie del mercato, per evitare vendite massive.</p>
<p>Posizioni contrattuali accumulate e trading guidato dalla volatilità: Durante la fase sopra descritta, i market maker hanno gradualmente costruito un numero consistente di posizioni contrattuali attraverso strategie di trading relativamente a basso costo. I dati provenienti da vari contratti di scambio hanno mostrato un incremento graduale della capitalizzazione di mercato dei contratti, che è passata da $52 milioni a $96 milioni durante la notte del 29 agosto alla mattina del 30 agosto. Il mercato secondario ha raggiunto l’obiettivo iniziale di $8.185, ma le posizioni contrattuali di mercato non hanno diminuito; anzi, sono aumentate, indicando che le posizioni iniziali non sono state completamente chiuse. Successivamente, il mercato ha sperimentato una forte volatilità.</p>
<p>Questo processo ha coinvolto anche sfruttare le liquidazioni nel mercato dei contratti per aumentare ulteriormente le posizioni lunghe (sfruttando i tassi di finanziamento negativi). La chiave era che i market maker controllavano ancora il prezzo del mercato spot, minimizzando i rischi associati alla negoziazione delle posizioni contrattuali.</p>
<p>Liquidazione e Profitti del Mercato dei Contratti: La strategia di liquidazione per CYBER è stata cruciale. I market maker hanno stabilito un numero significativo di posizioni corte elevate nel mercato dei contratti e indotto gli investitori al dettaglio ad aprire posizioni lunghe attraverso premi negativi e tassi di finanziamento elevati.</p>
<p>Come ha fatto CYBER a raggiungere tutto ciò in così breve tempo? L’impennata dei prezzi ha raggiunto 16,10 dollari, allineandosi con il tasso di finanziamento del mercato dei contratti al suo massimo tasso negativo di -2,50%. In soli cinque minuti, il prezzo ha raggiunto i 16,50 dollari, allineandosi precisamente con un picco della sequenza di Fibonacci, e il massimo tasso di finanziamento negativo è rapidamente aumentato fino a -0,162%.</p>
<p>Ciò suggerisce un consistente impiego di capitale nel mercato delle posizioni contrattuali corte, probabilmente attraverso il trading ad alta frequenza, utilizzando efficacemente le differenze tra i mercati spot e contrattuali per massimizzare significativi profitti in un breve periodo di tempo.</p>
<p>Nel mondo della finanza, il capitale domina tutto. Le tazze vuote non fanno rumore, ma quelle piene possono portare all’ubriachezza. Pensi che ci sia ancora un gioco a breve termine qui? Sembra che le opportunità si stiano riducendo man mano che l’interesse diminuisce.</p>
<h2 id="h2-Macro20Dati20non20agricoli20atterraggio20morbido20mercato20azionario20statunitense20chiuso20attenzione20alle20tendenze20delle20criptovalute559306"><a name="Macro: Dati non agricoli atterraggio morbido, mercato azionario statunitense chiuso, attenzione alle tendenze delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Dati non agricoli atterraggio morbido, mercato azionario statunitense chiuso, attenzione alle tendenze delle criptovalute</h2><p>Il rapporto non-farm pubblicato venerdì scorso, anche se in linea con la tendenza di un “atterraggio morbido”, l’indice del dollaro USA è rimbalzato rapidamente dai minimi intraday e ha chiuso in rialzo dello 0,64% a 104,28 a causa del suggerimento “hawking” del presidente della Fed di Cleveland Mester di un continuo inasprimento.</p>
<p>Il rendimento del Tesoro statunitense ha raggiunto un minimo di tre settimane dopo il rapporto sui non agricoli, ma poi si è ripreso anche, con il rendimento del Tesoro statunitense decennale che è salito dal 4,11% al 4,18%; Il rendimento del Tesoro statunitense a due anni ha registrato un piccolo aumento intraday di meno di 2 punti base.</p>
<p>L’oro spot ha brevemente superato la soglia di 1.950 dollari dopo l’annuncio del settore non agricolo, ma è poi crollato bruscamente a causa della “doccia fredda” versata da Messer, scendendo di quasi 20 dollari e chiudendo in ribasso dello 0,02% a 1.939,9 dollari/oncia. L’argento spot è sceso per tre giorni di contrattazioni consecutivi, chiudendo in ribasso dell’1,05%.</p>
<p>Dopo il sondaggio trimestrale di agosto negli Stati Uniti, la popolazione occupata non agricola è stata registrata a 187.000; Il tasso di disoccupazione registrato è del 3,8%, un nuovo massimo dal febbraio dell’anno scorso. Entrambi i dati erano superiori alle aspettative. Dopo la pubblicazione dei dati, il mercato ha una bassa probabilità che la Federal Reserve aumenti nuovamente i tassi di interesse quest’anno. Il mercato dei derivati ha completamente prezzato il momento in cui la Federal Reserve taglierà i tassi di interesse di 25 punti base da giugno prossimo anno a maggio.</p>
<p>Il Meister della Federal Reserve ha dichiarato che nonostante i segnali di un migliore equilibrio nel mercato del lavoro degli Stati Uniti, il mercato del lavoro statunitense rimane forte. Ha inoltre sottolineato che l’inflazione è ancora troppo alta e le future decisioni sui tassi di interesse si baseranno sui prossimi rilasci di dati.</p>
<p>Questo lunedì è una festa del lavoro negli Stati Uniti e il mercato statunitense sarà chiuso. Ci concentreremo sulle tendenze nel mercato delle criptovalute.</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 ripostaggio dell'articolo a condizione che venga citato Gate.io. In tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>