Tm90aXppZSBxdW90aWRpYW5lIHwgTGEgU0VDIHBvdHJlYmJlIGFuY29yYSB1bmEgdm9sdGEgcml0YXJkYXJlIGwnYXBwcm92YXppb25lIGRlZ2xpIEVURiBCaXRjb2luIFNwb3QsIGxhIENvcmVhIGRlbCBTdWQgaW5pemlhIGEgcGlhbmlmaWNhcmUgbGluZWUgZ3VpZGEgY3JpcHRvLCBpIHByZXp6aSBkZWwgcGF2aW1lbnRvIE5GVCBCbHV

2023-11-15, 04:30

<p><img src="https://gimg2.gateimg.com/image/article/17000286531_15.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20SEC20potrebbe20rinviare20nuovamente20lapprovazione20degli20ETF20Bitcoin20spot20il20mercato20NFT20di20Blue20chip20ha20registrato20una20ripresa39083"><a name="Crypto Daily Digest: La SEC potrebbe rinviare nuovamente l’approvazione degli ETF Bitcoin spot, il mercato NFT di Blue chip ha registrato una ripresa" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La SEC potrebbe rinviare nuovamente l’approvazione degli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot, il mercato NFT di Blue chip ha registrato una ripresa</h2><p>L’analista di Bloomberg James Seyfart ha twittato che la scadenza per la SEC degli Stati Uniti di prendere una decisione su tre <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Le applicazioni ETF spot si stanno avvicinando e è molto probabile che si vedrà un ordine ritardato dalla SEC. Ma questo non cambierà la nostra opinione che la probabilità che il 19b-4 sia approvato prima del 10 gennaio 2024 è del 90%. In risposta alla domanda degli utenti di Twitter sulla possibilità che gli ETF spot Bitcoin vengano approvati questa settimana, Seyfart ha dichiarato che la probabilità è inferiore al 50% ma superiore allo 0%.</p>
<p>Riguardo all’adozione degli ETF Bitcoin, Cathie Wood, CEO di ARK Invest, ha dichiarato in un’intervista con CNBC che, dato che Gary Gensler, presidente della Securities and Exchange Commission (SEC) degli Stati Uniti, è molto familiare con Bitcoin, è difficile trovare una ragione ragionevole per opporsi agli ETF spot.</p>
<p>Prima di ricoprire la carica di presidente della SEC, ha insegnato corsi di criptovalute e blockchain presso il Massachusetts Institute of Technology (MIT). Successivamente, Cathie Wood ha menzionato “speculazioni” riguardo al desiderio di Gensler di diventare Segretario del Tesoro degli Stati Uniti, che era “molto preoccupato per il dollaro statunitense”, suggerendo che l’ambizione di Gary Gensler di diventare Segretario del Tesoro potrebbe essere la vera ragione dell’ostacolo agli ETF di Bitcoin spot.</p>
<p>Wood ha anche previsto che alla fine gli ETF spot verranno approvati e ha affermato che entro il 2030 il valore di mercato delle criptovalute aumenterà dagli attuali 1 trilione di dollari a 25 trilioni di dollari. Attualmente, la SEC sta esaminando 12 domande di ETF spot su Bitcoin, tra cui ARK Invest.</p>
<p>Il consiglio di amministrazione di Boya Interactive, una società quotata presso la Borsa di Hong Kong, ha emesso una comunicazione agli azionisti, affermando che l’acquisto e il possesso di criptovalute sono una misura importante per la disposizione aziendale e lo sviluppo nel campo Web3, nonché un componente importante della strategia di allocazione degli asset del gruppo.</p>
<p>Dopo attenta considerazione, il consiglio di amministrazione raccomanda di cercare l’approvazione preventiva degli azionisti per concedere un’autorizzazione all’acquisto al consiglio di amministrazione per effettuare potenziali acquisti di criptovalute durante il periodo di autorizzazione, che è un periodo di 12 mesi dalla data di approvazione formale della risoluzione ordinaria sull’autorizzazione e potenziali acquisti di criptovalute da parte dell’assemblea speciale degli azionisti, con un importo totale di acquisto non superiore a $100 milioni.</p>
<p>In precedenza, ad agosto, la società quotata a Hong Kong Boya Interactive ha annunciato che il consiglio di amministrazione aveva approvato un budget di $5 milioni (circa 39,098 milioni di HKD) per l’acquisto di criptovalute su piattaforme di trading regolamentate e autorizzate, principalmente Bitcoin (BTC) e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> (ETH), nell’anno prossimo per guidare la futura configurazione aziendale nel campo Web3.</p>
<p>Boya Interactive ha anche rivelato che questa fonte di finanziamento sono riserve di denaro generate dalle attività del gruppo a Hong Kong e all’estero. L’acquisto di criptovaluta verrà eseguito in base alle condizioni di mercato e sarà strettamente conforme alle politiche di controllo delle giurisdizioni pertinenti in materia di criptovaluta.</p>
<p>Il 14 novembre, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a> ha annunciato il lancio ufficiale di un’applicazione mobile per gli utenti Android. Negli ultimi mesi, <a href="/price/uniswap-uni" target="_blank" class="blog_inner_link">Uniswap</a> è stato attentamente adattato ad Android per offrire la stessa esperienza di scambio che milioni di persone hanno avuto su Uniswap. In futuro, saranno rilasciate aggiornamenti ogni due settimane per accelerare la velocità di scambio e aggiungere più token e catene per lo scambio.</p>
<p>L’applicazione Uniswap è stata lanciata per la prima volta su iOS ad aprile ed è diventata una delle tre principali wallet per nuovi download in meno di un mese.</p>
<p>Di recente, l’Autorità monetaria sudcoreana ha istituito un Task Force sulla quotazione di asset virtuali (TF) per discutere gli standard regolatori (linee guida) per la quotazione, il mantenimento della quotazione e la rimozione dalla quotazione. Il task force include autorità finanziarie, settori pubblico e privato ed esperti esterni. Una persona dell’Autorità di vigilanza finanziaria ha dichiarato che “pianifichiamo di trarre delle conclusioni e presentare una relazione al Congresso qualche mese prima dell’entrata in vigore della Legge sulla Protezione degli Utenti di Asset Massimi nel luglio dell’anno prossimo”, e ha aggiunto che “studeremo come adottare misure per migliorare l’efficacia degli standard (sotto la supervisione delle autorità finanziarie) e garantire che il settore possa proteggerli attraverso l’autoregolamentazione.”</p>
<p>Secondo i dati di Blur, il prezzo del pavimento NFT di blue chip è recentemente ripartito al rialzo. Tra questi, il prezzo del pavimento della serie BAYC è attualmente di 30,37 ETH, con un aumento settimanale del 6,73%; Il prezzo del pavimento della serie MAYC è attualmente di 5,72 ETH, con un aumento settimanale del 5,43%; Il prezzo del pavimento della serie Azuki è attualmente di 6,06 ETH, con un aumento settimanale del 17,06%; Il prezzo del pavimento di Doodles è attualmente di 2,21 ETH, con un aumento settimanale del 14,51%. Inoltre, il token BEND del protocollo di prestito NFT BendDAO viene attualmente quotato a $0,005476, con un aumento del 29% nelle ultime 24 ore.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi75112"><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-BTC141328"><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/1700028696BTC.png" alt=""><br>Il grafico giornaliero ha ritracciato fino al supporto di $34.870, formando un supporto efficace come precedentemente menzionato. Ulteriore supporto si trova a $33.085 e $32.765. Questa settimana continua con un trend di ritracciamento elevato. La strategia a lungo termine suggerisce una posizione a basso livello continua, con cautela contro la volatilità a livello elevato.</p>
<h3 id="h3-ETH248269"><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/1700028720ETH.png" alt=""><br>Il grafico giornaliero tenta un terzo breakout a $2.135, ma manca di slancio. Un ritracciamento a $1.951 è possibile se $2.000 non fornisce supporto. La struttura a breve termine potrebbe continuare a ritracciarsi all’interno del range discendente. Si consiglia di mantenere le posizioni corte a $1.951.</p>
<h3 id="h3-FTT155435"><a name="FTT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FTT</h3><p><img src="https://gimg2.gateimg.com/image/article/1700028742FTT.png" alt=""><br>Dato il trend generale da $1.3965 a $5, questa mattina è stata osservata una convergenza e un movimento verso l’alto a breve termine. Si consiglia di mantenere la resistenza a $3.67. Un mancato consolidamento potrebbe portare a una falsa rottura, facendo retrocedere il mercato al minimo di $3.21. Si consiglia cautela a breve termine.</p>
<h2 id="h2-Macro20CPI20inferiore20alle20aspettative20il20ciclo20di20rialzo20dei20tassi20di20interesse20potrebbe20essere20terminato80163"><a name="Macro: CPI inferiore alle aspettative, il ciclo di rialzo dei tassi di interesse potrebbe essere terminato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: CPI inferiore alle aspettative, il ciclo di rialzo dei tassi di interesse potrebbe essere terminato</h2><p>Martedì, dati sull’inflazione inferiori alle aspettative negli Stati Uniti hanno alimentato la speranza che la Federal Reserve avesse completato l’aumento dei tassi di interesse.</p>
<p>L’indice del dollaro statunitense ha raggiunto quota 104 durante la sessione, segnando la prima volta dal 1° settembre e chiudendo infine in calo del 1,523% a 104,07. Le valute non statunitensi si sono complessivamente rallegrate, con l’euro che è salito oltre 1,08 contro il dollaro statunitense, un nuovo massimo dal 4 settembre. La sterlina ha toccato un nuovo massimo di due mesi di 1,25 contro il dollaro statunitense. Il dollaro statunitense è sceso fino al 1% contro lo yen giapponese durante la giornata. Il dollaro neozelandese ha toccato 0,60 contro il dollaro statunitense per la prima volta dall’6 novembre, salendo di oltre il 2% in un giorno. Il dollaro australiano si è attestato a 0,65 contro il dollaro statunitense, un nuovo massimo dal 7 novembre, con un aumento giornaliero di oltre il 2%.</p>
<p>I tre principali indici azionari statunitensi hanno chiuso in rialzo, con il Dow Jones Index in aumento dell’1,43%, il Nasdaq in aumento del 2,37% e l’indice S&amp;P 500 in aumento del 1,9%. Tesla (TSLA.O) è salita del 6%, NVDA.O (NVDA.O) è salita del 2% e Microsoft (MSFT.O) è salita quasi dell’1%, chiudendo a un valore di mercato storico.</p>
<p>Il rendimento dei titoli di Stato statunitensi è crollato lungo tutta la linea, con un calo complessivo di circa 20 punti base. Il rendimento del Tesoro statunitense decennale è chiuso al 4,453%; Il rendimento del Tesoro statunitense a due anni, che è più sensibile ai tassi di interesse della politica della Federal Reserve, è sceso ancora di più, chiudendo al 4,836%.</p>
<p>L’oro spot ha continuato a salire dopo la pubblicazione di dati CPI inaspettatamente in calo, toccando il livello 1970 e chiudendo infine in rialzo dello 0,89% a $1963,18 per oncia, registrando la sua migliore performance giornaliera dal 27 ottobre; l’argento spot si è ripreso fino a quota 23 e ha chiuso in rialzo del 3,51% a $23,09 per oncia.</p>
<p>I prezzi internazionali del petrolio sono leggermente diminuiti e hanno chiuso leggermente più bassi nel mercato statunitense a causa della mancanza di segnali chiari di escalation delle tensioni in Medio Oriente e dell’incertezza sugli inventari petroliferi statunitensi. Il petrolio greggio WTI è sceso dello 0,41% a $78,16 al barile; il petrolio greggio Brent ha chiuso lo 0,29% in ribasso a $82,39 al barile.</p>
<p>L’IPC complessivo e di base degli Stati Uniti sono stati entrambi inferiori alle aspettative, con un tasso IPC annuo non regolamentato del 3,2% nel mese di ottobre e un tasso mensile di base IPC dello 0,2%. Il ciclo attuale di prezzatura dei futures sui tassi di interesse da parte della Federal Reserve è completamente giunto al termine, ed è previsto un taglio dei tassi di interesse di 100 punti base entro la fine dell’anno prossimo, con la prima fase di taglio dei tassi prevista già a maggio.</p>
<p>L’indice di fiducia delle piccole imprese NFIB negli Stati Uniti è diminuito di 0,1 punti percentuali a ottobre, attestandosi a 90,7, il punto più basso degli ultimi cinque mesi, principalmente a causa del peggioramento dei profitti causato da vendite deboli e costi in aumento. Quasi un terzo del reddito netto delle piccole imprese è diminuito negli ultimi tre mesi, la proporzione più alta da più di un anno. Questo deterioramento indica che la domanda dei consumatori potrebbe diminuire dopo una crescita costante nel terzo trimestre.</p>
<p>Presidente della Fed di Chicago Goolsby: Il progresso dell’inflazione è in corso, ma c’è ancora un po’ da fare. Nuova Agenzia di Notizie della Federal Reserve: Il ciclo di rialzo dei tassi di interesse potrebbe essere giunto al termine, con un’attenzione alla revisione delle linee guida della dichiarazione in futuro. Vice Presidente della Federal Reserve Jefferson: L’incertezza della persistenza dell’inflazione potrebbe richiedere una risposta politica più forte rispetto ad altre situazioni.</p>
<p>La Fed è nell’ultima fase di lotta all’inflazione e la soglia per ulteriori aumenti e tagli dei tassi di interesse potrebbe essere piuttosto alta. Questo rilascio di dati non influenzerà la situazione complessiva, poiché la Federal Reserve ha bisogno di vedere più copie dei dati - pertanto, ci si aspetta che l’impatto di questo rilascio di dati sul mercato sarà limitato. Wall Street è concentrata sull’IPC di base. Originariamente, il mercato si aspettava che il calo fosse praticamente stagnante, ma sia il tasso annuale che quello mensile erano inferiori alle aspettative di mercato. In particolare, la diminuzione mensile dello 0,2% è in linea con l’obiettivo di inflazione del 2%.</p>
<p>Tuttavia, il tasso annuale del CPI core a ottobre rimane il doppio dell’obiettivo di inflazione della Federal Reserve. Ma la Federal Reserve cambierà il suo atteggiamento di falco a meno che il CPI core mensile rimanga stabile al 0,2% -0,3% per almeno sei mesi consecutivi.</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. La ripubblicazione dell'articolo sarà consentita 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>