Tm90aXppZSBxdW90aWRpYW5lIHwgRGl2ZXJzaSBnaWdhbnRpIGZpbmFuemlhcmkgaGFubm8gb3R0ZW51dG8gY29kaWNpIGRpIHRyYWRpbmcgRVRGIEJpdGNvaW47IElsIHRyYWRpbmcgZGkgaXNjcml6aW9uZSBoYSBmYXR0byByaXNhbHRhcmUgQXZhbGFuY2hlOyBJbCB2b2x1bWUgZGkgdHJhZGluZyBORlQgZGkgU29sYW5hIHN1cGVyYSB

2023-12-19, 04:20

<p><img src="https://gimg2.gateimg.com/image/article/17029685581_13.png" alt=""></p>
<h2 id="h2-Sommario20giornaliero20del20mondo20delle20criptovalute20ultime20novit20sugli20ETF20Bitcoin20spot20il20volume20di20trading20NFT20di20Solana20supera20per20la20prima20volta20quello20di20Ethereum550784"><a name="Sommario giornaliero del mondo delle criptovalute: ultime novità sugli ETF Bitcoin spot, il volume di trading NFT di Solana supera per la prima volta quello di Ethereum" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sommario giornaliero del mondo delle criptovalute: ultime novità sugli ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot, il volume di trading NFT di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> supera per la prima volta quello di Ethereum</h2><p>L’avvicinamento <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> L’ETF spot ha compiuto nuovi progressi.</p>
<p>Watcher.Guru ha twittato che l’ETF Bitcoin spot di ARK Invest e 21Shares è stato aggiunto al sito web della Depository Trust and Clearing Corporation (DTCC) con il codice di transazione ARKB.</p>
<p>Secondo The Block, l’ETF proposto da BlackRock per Bitcoin spot ha ricevuto il codice di negoziazione “IBIT” basato su un documento S-1 rivisto presentato alla US Securities and Exchange Commission (SEC) lunedì. Il documento aggiornato include anche nuove parole riguardanti il modello di riscatto in contanti rispetto al modello di riscatto fisico, che è stato oggetto di incontri recenti tra BlackRock e funzionari della SEC.</p>
<p>L’analista di Bloomberg, James Seyfhart, ha twittato che la SEC degli Stati Uniti ha aperto un periodo di revisione per determinare se <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Gli ETF spot dovrebbero essere trattati diversamente dagli ETF spot di Bitcoin. In precedenza, la SEC aveva rinviato la decisione su diverse domande di ETF spot di Bitcoin, tra cui Hashdex, Grayscale, ARK 21Shares e VanEck.</p>
<p>Inoltre, la società di gestione patrimoniale statunitense Wisdomtree ha presentato il quarto prospetto rivisto dell’ETF spot Bitcoin alla SEC, e la piccola società di gestione patrimoniale crypto 7RCC, che si concentra sull’ESG, ha presentato una domanda di ETF spot Bitcoin alla SEC statunitense.</p>
<p>Con la crescente popolarità del settore delle iscrizioni, varie catene pubbliche stanno iniziando a fare i loro sforzi.</p>
<p>Il 18 dicembre, secondo The Block, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Valanga</a> Negli ultimi cinque giorni gli utenti hanno pagato 13,8 milioni di dollari in commissioni per iscrizioni, inclusa l’incisione e il trasferimento. Sebbene siano stati creati decine di milioni di token basati su iscrizioni su blockchain come <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> e <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> In Chain, il costo totale pagato dagli utenti è approssimativamente 1 milione di dollari per catena.</p>
<p>Il 18 dicembre, secondo The Block, nella scorsa settimana, gli utenti di <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> hanno distrutto 439.000 AVAX del valore approssimativo di 16,7 milioni di dollari durante le transazioni, riducendo l’offerta circolante del token. Il numero di AVAX distrutti a settimana è salito al livello più alto finora.</p>
<p>Sulla rete Avalanche, tutte le commissioni di transazione vengono distrutte. I costi di transazione all’interno della rete si basano sul design EIP-1559, che introduce un elemento di distruzione nei costi di transazione di Ethereum. La differenza è che <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> paga una parte delle commissioni di transazione al verificatore e distrugge la parte restante, mentre Avalanche viene completamente distrutto.</p>
<p>Secondo gli ultimi dati di Dune, il ricavo totale dalla protocollo Bitcoin NFT di incisione di iscrizioni di Ordinals supera i 4234 BTC, circa $173,448,605, e il numero totale attuale di iscrizioni effettuate raggiunge 49,127,513.</p>
<p>Il numero di iscrizioni sulla catena Ethereum EVM è aumentato, portando ad un aumento del consumo di GAS. Secondo Dune Analytics, il 16 dicembre il costo del gas utilizzato per le iscrizioni è salito a un massimo storico di $8,3 milioni. La rete Avalanche ha consumato la maggior quantità di gas, spendendo oltre $5,6 milioni solo lo stesso giorno. Aribitrum One si classifica al secondo posto, con un costo di $2,1 milioni per il Gas di iscrizione.</p>
<p>Nelle ultime 24 ore, il 58% del gas di rete di Avalanche è stato speso per le iscrizioni EVM, mentre il 48% delle spese di zkSync Era è stato speso per le iscrizioni EVM. Inoltre, il 73% delle transazioni di <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain nelle ultime 24 ore erano legate alle iscrizioni. Questa situazione è stata molto grave sulla rete Arbitrum One, causando un’interruzione di 78 minuti il 15 dicembre.</p>
<p>Nel frattempo, la rete Bitcoin ha visto anche un aumento delle iscrizioni nel fine settimana, aumentando la domanda di spazio di blocco e costi di transazione. Secondo i dati di Mempool.Space, attualmente ci sono quasi 280.000 transazioni non confermate. Gli osservatori sostengono che ciò ha portato i costi delle transazioni Bitcoin a salire a $37, rendendo impossibile per la maggior parte delle persone utilizzare la rete Bitcoin per valuta digitale peer-to-peer.</p>
<p>L’esperto NFT e degli ordinali Leonidas ha notato che nelle ultime 24 ore, le vendite di una singola serie di iscrizioni (progetto non specificato) hanno superato il totale di CryptoPunks, BAYC, MAYC, Pudgy Penguins, Azuki, DeGods, Moonbirds, Doodles e Meebits, e ha dichiarato che la serie di Bitcoin Frogs si è classificata al primo posto nella serie Ordinal PFP con un valore di mercato di $182 milioni.</p>
<p>D’altra parte, <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Gli NFT stanno gradualmente riprendendo. Negli ultimi 7 giorni, il volume delle transazioni di NFT di Solana ha raggiunto 92,06 milioni di dollari, superando per la prima volta il volume di transazioni di NFT di Ethereum pari a 91,32 milioni di dollari nello stesso periodo. Inoltre, negli ultimi 7 giorni, il volume delle transazioni di NFT di Bitcoin ha raggiunto i 365 milioni di dollari.</p>
<p>Secondo Cointelgraph, i prestiti basati su blockchain stanno riprendendo quest’anno, con il valore del credito privato tokenizzato attivo che attualmente raggiunge i $582 milioni, un aumento del 128% rispetto all’anno scorso. Secondo i dati di RWA.xyz, anche se è ancora lontano dal picco di $1,5 miliardi di giugno 2022. Questa ripresa potrebbe indicare che, con l’attuale aumento dei tassi di interesse, coloro che cercano prestiti stanno cercando alternative finanziarie tradizionali basate su blockchain.</p>
<p>Secondo un rapporto di NerdWallet del 1° dicembre, il tasso di interesse medio per i protocolli di credito basati su blockchain è attualmente del 9,64%, mentre il tasso di interesse per i prestiti bancari alle piccole imprese forniti dai finanziatori varia dal 5,75% all’11,91%. Anche i prestiti concessi sono considerevoli, con RWA.xyz che monitora $4,5 miliardi di prestiti blockchain in 1804 transazioni, il che significa un prestito medio di circa $2,5 milioni.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi646808"><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-BTC477064"><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/1702968608BTC.png" alt=""><br>Il grafico a quattro ore ha toccato il livello di supporto di $40.280 e si è ripreso, raggiungendo il limite superiore del trend ribassista a breve termine. Prestare attenzione alla convergenza della struttura a medio termine ai livelli elevati. Considerare posizioni lunghe e corte in base al canale di salita complessivo. Resistenza a due livelli elevati: $45.345 e $47.990; Supporto a due livelli inferiori: $40.280 e $38.399.</p>
<h3 id="h3-ETH372781"><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/1702968628ETH.png" alt=""><br>I livelli alti continuano a oscillare sopra i $2.135 questa settimana, testando il supporto a $2.135 ieri e ritirandosi. La stabilità a breve termine sopra i $2.135 è cruciale. Due livelli di supporto al di sotto sono $2.037 e $1.974. Tenere d’occhio la rottura del livello di resistenza a $2.381, che indica una possibile continuazione del movimento in un range medio.</p>
<h3 id="h3-GT771482"><a name="GT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>GT</h3><p><img src="https://gimg2.gateimg.com/image/article/1702968648GT.png" alt=""><br>Il grafico settimanale entra nella seconda fase del mercato rialzista, stabilizzandosi e salendo chiaramente. Supporto a breve termine alla linea bianca e supporto a lungo termine a $2.88. Ottimista per i segnali precoci che guidano la crescita delle altcoin. Prezzi target: $12.877, $18.977, $28.58, $44.99. Si consiglia di mantenere posizioni a lungo termine in asset spot.</p>
<h2 id="h2-Macro20Diversi20funzionari20della20Federal20Reserve20escono20per20raffreddare20i20tagli20dei20tassi20di20interesse20potrebbero20essere20troppo20precoci818768"><a name="Macro: Diversi funzionari della Federal Reserve escono per ‘raffreddare’, i tagli dei tassi di interesse potrebbero essere troppo precoci" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Diversi funzionari della Federal Reserve escono per ‘raffreddare’, i tagli dei tassi di interesse potrebbero essere troppo precoci</h2><p>Lunedì, i rendimenti dei titoli di Stato americani sono prima diminuiti e poi aumentati. Il rendimento del titolo di Stato americano decennale è sceso al minimo di 5 mesi, pari al 3,890%, durante la negoziazione, per poi aumentare significativamente prima dell’apertura del mercato americano, chiudendo infine al 3,935%; Il rendimento del titolo di Stato americano a due anni, più sensibile ai tassi di interesse della politica della Federal Reserve, ha chiuso al 4,450%.</p>
<p>L’indice del dollaro statunitense è sceso in una fascia e si è stabilizzato sopra 102, chiudendo infine in calo dello 0,07% a 102,52. L’indice di borsa statunitense è salito leggermente, con l’indice S&amp;P 500 in rialzo dello 0,45% e il Nasdaq in rialzo dello 0,61%.</p>
<p>Anche l’oro spot è sceso in un intervallo, superando il livello 2030 nel mercato statunitense in un momento, ma non riuscendo a stabilizzarsi qui, chiudendo infine in rialzo dello 0,37% a $2027,23/oncia; l’argento spot non è riuscito a stabilizzarsi sopra il livello 24 e ha chiuso infine in ribasso dello 0,3% a $23,8 per oncia.</p>
<p>A causa degli attacchi in aumento alle navi mercantili del Mar Rosso, il petrolio greggio internazionale è aumentato di quasi il 2%. Il greggio WTI è salito fino a un massimo intraday di $ 74,58 nella sessione di trading, poi ha ceduto parte dei suoi guadagni e alla fine ha chiuso in rialzo del 1,5% a $ 72,81 al barile; il greggio Brent si è avvicinato brevemente alla soglia dei $ 80 nella sessione di trading, chiudendo alla fine in rialzo del 1,42% a $ 77,95 al barile.</p>
<p>Lunedì, diversi funzionari della Federal Reserve hanno nuovamente avvertito che le aspettative del mercato per il taglio dei tassi d’interesse della Fed erano in qualche modo in anticipo rispetto alla tabella di marcia, segnando l’ultimo tentativo della Fed di frenare l’ascesa dei mercati azionari e dei prezzi dei bond.</p>
<p>Nello stesso giorno, il presidente della Fed di Cleveland e membro del comitato di voto del FOMC del 2024, Mester, ha anche smentito le aspettative esterne secondo cui, dal momento che la Federal Reserve è più fiduciosa nell’aumentare i tassi di interesse di riferimento a un livello sufficiente per controllare l’inflazione, si sposterà improvvisamente verso la riduzione dei costi di prestito.</p>
<p>Mester ha dichiarato in un’intervista al Financial Times che la prossima fase della questione non è quando tagliare i tassi di interesse. Anche se il mercato è attualmente in questa fase, il vero problema è quanto tempo la politica monetaria deve rimanere restrittiva per garantire che l’inflazione possa continuare e tornare al 2% in modo tempestivo. Ha aggiunto che il mercato era un po’ avanti rispetto ai tempi previsti e sono passati all’ultima parte, che era “la Federal Reserve si normalizzerà rapidamente”, cosa che non era nei suoi pronostici.</p>
<p>Le osservazioni di Mester sono in linea con le opinioni di altri due membri del FOMC - il presidente della Federal Reserve di New York, Williams, e il presidente della Federal Reserve di Atlanta, Bostic, che hanno sottolineato venerdì scorso che i tagli dei tassi di interesse non arriveranno immediatamente. Il presidente della Federal Reserve di San Francisco, Daley, ritiene che potrebbero essere necessari tre tagli dei tassi di interesse nel 2024. Inoltre, il presidente della Federal Reserve di Chicago, Goolsby, ritiene che la Federal Reserve non dovrebbe agire in base alle reazioni del mercato.</p>
<p>Poiché la Federal Reserve ha tenuto la sua ultima riunione di politica monetaria per il 2023 la scorsa settimana, i trader del mercato dei futures hanno aumentato le loro scommesse sul fatto che la Fed taglierà i tassi di interesse già a partire da marzo e porterà infine il tasso dei fondi federali leggermente al di sotto del 4% il prossimo anno dal suo attuale massimo di 22 anni del 5,25% -5,5%.</p>
<p>Il catalizzatore che ha portato all’incremento rapido delle aspettative di mercato per i tagli dei tassi di interesse è stato il messaggio accomodante rilasciato dal presidente della Federal Reserve Powell. Ha mostrato fiducia nelle prospettive della Federal Reserve nel controllare l’inflazione la scorsa settimana e ha riconosciuto che gli ufficiali stanno discutendo della questione dei tagli dei tassi di interesse. Il riassunto delle nuove previsioni economiche rilasciate la scorsa settimana ha anche mostrato che la maggior parte dei responsabili politici sostiene una riduzione di 75 punti base nel tasso di riferimento della politica nel 2024, una ulteriore riduzione di 100 punti base nel 2025 e un ulteriore calo al di sotto del 3% nell’anno successivo.</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, saranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p><br></div></div></div></div>