Tm90aXppZSBxdW90aWRpYW5lIHwgTGEgcGnDuSBncmFuZGUgYmFuY2EgZGVsIEJyYXNpbGUgYXZ2aWEgaSBzZXJ2aXppIGRpIGNyaXB0b3ZhbHV0ZSwgc2lhIGlsIHRyYWRpbmcgb24tY2hhaW4gZGkgQml0Y29pbiBjaGUgaWwgdm9sdW1lIGRpIHRyYWRpbmcgc3BvdCBkaSBDRVggcmFnZ2l1bmdvbm8gbGl2ZWxsaSBzdG9yaWNpIGEgbm9

2023-12-05, 04:07

<p><img src="https://gimg2.gateimg.com/image/article/17017587191_3.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20La20pi20grande20banca20del20Brasile20offre20servizi20criptati20il20Bitcoin20di20El20Salvador20ha20un20profitto20fluttuante20di203620milioni243171"><a name="Crypto Daily Digest: La più grande banca del Brasile offre servizi criptati, il Bitcoin di El Salvador ha un profitto fluttuante di $3.6 milioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: La più grande banca del Brasile offre servizi criptati, il <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> di El Salvador ha un profitto fluttuante di $3.6 milioni</h2><p>Secondo Reuters, Itau Unibanco, la più grande istituzione bancaria del Brasile, ha lanciato servizi di trading di criptovalute per i suoi clienti della piattaforma di investimento il 4 dicembre. Itau funge anche da custode per proteggere gli asset degli utenti. Questa mossa consente a Itau di competere con giganti globali come MB, la borsa di criptovalute, Mynt, la divisione di asset digitali della banca d’investimento BTG Pactual (BPAC3.SA), e Binance in Brasile.</p>
<p>Guto Antunes, il responsabile degli asset digitali della banca, ha dichiarato in un’intervista che il nuovo servizio di Itau permetterà inizialmente di negoziare <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a>(la criptovaluta più popolare) e <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, ma l’obiettivo della banca è espandersi ad altre criptovalute in futuro.</p>
<p>Recentemente, il presidente salvadoregno Nayib Bukele ha approfittato dell’impennata dei prezzi e ha twittato a proposito del lungo termine <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> di Bitcoin: L’investimento di El Salvador in Bitcoin ha raggiunto la redditività.</p>
<p>Nonostante migliaia di rapporti e articoli critici che deridono le presunte perdite di El Salvador, calcolate in base al prezzo di mercato del Bitcoin al momento, in base al prezzo attuale di mercato del Bitcoin, Nayib Bukele ha anche dichiarato che se El Salvador vende il suo Bitcoin, può non solo recuperare il 100% dell’investimento ma anche generare un profitto di 3,62 milioni di dollari. El Salvador non ha intenzione di vendere Bitcoin, che non è mai stato il suo obiettivo. Siamo ben consapevoli che i prezzi continueranno a fluttuare in futuro, ma ciò non influisce sulla nostra strategia a lungo termine.</p>
<p>Secondo The Block, Robinhood ha dichiarato in una presentazione 8-K alla Securities and Exchange Commission (SEC) lunedì che il volume nominale di trading di criptovalute della piattaforma è aumentato di circa il 75% mese su mese a novembre. Questo potrebbe segnare una inversione delle prestazioni di trading dell’azienda.</p>
<p>Il volume di transazioni di criptovalute di Robinhood nel terzo trimestre di quest’anno è diminuito del 55% su base annua a $23 milioni. Nel secondo trimestre, il suo fatturato di trading di criptovalute è diminuito anche del 18% su base mensile. Robinhood ha precedentemente dichiarato di avere piani per iniziare ad offrire il trading di criptovalute nell’Unione Europea nelle prossime settimane.</p>
<p>Il 5 dicembre, CoinDesk ha pubblicato la lista annuale dei personaggi più influenti del 2023, con lo scopo di “riconoscere coloro che hanno definito l’anno nei campi degli asset digitali e di Web3, indipendentemente dal bene o dal male.” Include 50 individui ed entità premiati, con i primi 10 che hanno avuto un impatto significativo.</p>
<p>Sono Casey Rodarmor, fondatore del protocollo Bitcoin Ordinals; fondatore di Messari Ryan Selkis; Jenny Johnson, CEO di Franklin Templeton; <a href="/price/lido-dao-ldo" rel="nofollow noopener noreferrer" target="_blank">Lido DAO</a>; Paolo Ardoino, Chief Technology Officer di <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a>; Jose Fernandez da Ponte, Vicepresidente Senior di PayPal; Gary Gensler, Presidente della SEC degli Stati Uniti; il co-fondatore di Coinbase Brian Armstrong; il CEO di OpenAI Sam Altman; e il CEO di Ripple Brad Garlinghouse.</p>
<p>In termini di dati, secondo DefiLlama, il valore totale bloccato (TVL) dei protocolli DeFi in tutta la rete ha superato i 50 miliardi di dollari il 4 dicembre, con un aumento del 2,3% nelle ultime 24 ore. Tra questi, il TVL di Lido è il più alto, a 21,1 miliardi di dollari, in aumento del 4,19% nelle ultime 24 ore; Maker si è classificato al secondo posto con 8,7 miliardi di dollari, in aumento del 2,59% nelle ultime 24 ore; <a href="/price/aave-aave" target="_blank" class="blog_inner_link">AAVE</a> si posiziona al terzo posto con 6,3 miliardi di dollari, in aumento del 3,52% nelle ultime 24 ore.</p>
<p>Il 4 dicembre, secondo i dati di The Block, il numero di transazioni on-chain di Bitcoin ha raggiunto un massimo storico di 16,42 milioni a novembre. Il precedente massimo storico era di 16,3 milioni di transazioni a maggio di quest’anno. Il volume di trading spot di CEX a novembre ha raggiunto 826,4 miliardi di dollari, un nuovo massimo da marzo di quest’anno, con un aumento mensile di oltre il 60% rispetto ai 516,43 miliardi di dollari di ottobre.</p>
<p>Inoltre, la quota di mercato del trading spot di Binance è scesa al 37,52%. La quota di mercato precedente di Binance nel mese di ottobre era del 40,47%.</p>
<p>Sulla base delle recenti tendenze di mercato, a causa delle scommesse di mercato secondo cui la Federal Reserve ha completato gli aumenti dei tassi e inizierà a tagliare i tassi all’inizio del 2023, Bitcoin ha superato i 40.000 dollari per la prima volta quest’anno, raggiungendo il suo livello più alto da aprile 2022.</p>
<p>Inoltre, il prezzo di Bitcoin raddoppierà nel 2024 e il mercato sembra aver superato l’inverno delle criptovalute causato dagli scandali come il crollo dell’exchange FTX dell’anno scorso. Accogliamo insieme l’arrivo di un mercato rialzista dimezzato.</p>
<h2 id="h2-Tendenze20principali20dei20token20di20oggi343447"><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-BTC787155"><a name="BTC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BTC</h3><p><a href="/how-to-buy/rocket-pool-rpl" rel="nofollow noopener noreferrer" target="_blank">dove comprare Rocket Pool</a><br>Il Bitcoin (BTC) ha registrato tre guadagni mensili consecutivi, mostrando segni di un potenziale picco a breve termine. L’outlook a lungo termine rimane ottimista, con una strategia di attesa di una svolta a $37.980, puntando a $40.495 e $42.015. Si noti che il breve termine è relativamente alto, con una posizione corta a $40.500. L’obiettivo rialzista a lungo termine è fissato a $120.400 e $128.350, con un previsto pullback nel primo trimestre del prossimo anno.</p>
<h3 id="h3-ETH813619"><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/1701758794ETH.png" alt=""><br>Ethereum (ETH) ha rotto con successo la resistenza di $2.135 questa settimana, ma il momentum al rialzo è relativamente debole. Nel breve termine, suggerisce di attendere un pullback, concentrarsi sul supporto a $2.180 e mirare a $2.381. La recensione raccomanda di tenere d’occhio il settore delle altcoin per la leadership nel breve termine.</p>
<h3 id="h3-BIGTIME580484"><a name="BIGTIME" class="reference-link"></a><span class="header-link octicon octicon-link"></span>BIGTIME</h3><p><img src="https://gimg2.gateimg.com/image/article/1701758816BIGTIME.png" alt=""><br>BIGTIME, che si trova in posizione dal tardo ottobre, è rimasto tranquillo per oltre un mese con posizioni spot a $0,07450 e $0,09350. Ora ha subito un significativo aumento, raggiungendo $1 al mattino con un guadagno complessivo di oltre dieci volte.</p>
<p>Il breve termine ha raggiunto un punto alto, con obiettivi di medio termine a $1.1474 e $1.3210. Tracciando paralleli con GMT e MANA (entrambi guidati dal CEO di Bigtime), GMT ha raggiunto il suo primo picco di $0.8420 entro due settimane e in seguito è retrocesso a $0.598. Alla fine GMT ha raggiunto il picco a $3.1311, rappresentando un aumento di 311 volte rispetto al prezzo di apertura di $0.01.</p>
<p>MANA ha mostrato un costante aumento da $0.0582 al suo primo obiettivo di $1.5792, raggiungendo un aumento del 2.717%. Con un picco di capitalizzazione di mercato di $9 miliardi, MANA ha fornito ampio spazio per il mercato del Metaverso per prosperare. Considerando i valori di picco di GMT e MANA, BIGTIME ha ancora un notevole potenziale di mercato.</p>
<p>Ecco perché abbiamo raccomandato il mantenimento a lungo termine prima che BIGTIME andasse in diretta, anticipando una possibile violazione del livello di $1 nel medio termine. Le prospettive a lungo termine suggeriscono di guidare l’intero mercato Metaverse e spingere la capitalizzazione di mercato verso nuove vette, creando una situazione vantaggiosa sia per i detentori di spot che di contratti.</p>
<h2 id="h2-Macro20Il20prezzo20delloro2020come20un20giro20sulle20montagne20russe20Goldman20Sachs20prevede20tagli20dei20tassi20di20interesse20nel20quarto20trimestre20dellanno20prossimo756577"><a name="Macro: Il prezzo dell’oro è come un giro sulle montagne russe, Goldman Sachs prevede tagli dei tassi di interesse nel quarto trimestre dell’anno prossimo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Il prezzo dell’oro è come un giro sulle montagne russe, Goldman Sachs prevede tagli dei tassi di interesse nel quarto trimestre dell’anno prossimo</h2><p>Lunedì, i rendimenti del Tesoro degli Stati Uniti si sono ripresi leggermente, con i rendimenti del Tesoro decennale che hanno registrato una flessione di oltre 10 punti base, chiudendo al 4,257%; Il rendimento del Tesoro statunitense a due anni, che è più sensibile ai tassi di interesse delle politiche della Federal Reserve, si è ripreso ancora di più, chiudendo al 4,635%.</p>
<p>Dopo tre settimane consecutive di calo, l’indice del dollaro USA ha recuperato parte delle perdite e ha rimbalzato ad un massimo di una settimana, chiudendo infine in calo dello 0,436% a 103,65. Le tre principali borse statunitensi hanno chiuso collettivamente in ribasso. Il Dow ha chiuso in calo dello 0,12% o 40 punti, il Nasdaq è salito dello 0,84% e l’indice S&amp;P 500 è diminuito dello 0,54%.</p>
<p>L’oro fisico ha aperto con un aumento di oltre $70, raggiungendo un picco di 2144.61, rompendo un nuovo massimo storico. Successivamente, ha continuato a recuperare i suoi guadagni, scendendo di oltre $120 rispetto al massimo giornaliero e chiudendo infine in calo del 2.07% a $2,029 per oncia;<br>L’argento fisico è aumentato e diminuito, chiudendo infine in calo del 3.83% a $24.5 per oncia.</p>
<p>Nonostante l’Arabia Saudita abbia dichiarato che la riduzione della produzione può essere estesa oltre il primo trimestre dell’anno prossimo, il trend del petrolio greggio internazionale rimane debole. Il petrolio greggio WTI è sceso dell’1,5% a $73,23 al barile; il petrolio greggio Brent ha continuato a scendere al di sotto dei $79, chiudendo infine in ribasso dell’1,21% a $78,14 al barile.</p>
<p>Secondo lo strumento FedWatch del Chicago Mercantile Exchange, fino a lunedì, i trader ritengono che lo scenario più probabile sia che la Federal Reserve ridurrà i tassi di interesse cinque volte prima della fine del 2024. All’apertura di lunedì, l’oro è improvvisamente salito a un massimo storico di $2,144 per oncia. L’analisi di mercato ritiene generalmente che ciò sia strettamente correlato alle aspettative di taglio dei tassi di interesse della Federal Reserve.</p>
<p>Gli economisti di Goldman Sachs prevedono che la Federal Reserve ridurrà i tassi di interesse solo una volta nel 2024, probabilmente nel quarto trimestre. Attualmente, c’è una differenza significativa nelle aspettative delle principali banche d’investimento di Wall Street per i tagli dei tassi di interesse, con UBS che si aspetta che la Federal Reserve tagli i tassi più volte. Il team di Goldman Sachs ha sottolineato che dopo la dichiarazione moderata del governatore della Federal Reserve Waller della scorsa settimana, il mercato l’ha interpretata come una luce verde per futuri tagli dei tassi di interesse - se l’inflazione continua a indebolirsi, i tagli dei tassi potrebbero iniziare già la prossima primavera.</p>
<p>Il presidente della Federal Reserve Powell ha cercato di confutare queste aspettative nel suo discorso lo scorso venerdì, ma gli investitori non hanno risposto a ulteriori aumenti dei tassi di interesse e invece hanno concentrato la loro attenzione sui cambiamenti sottili nel suo modo di descrivere il restringimento delle condizioni di finanziamento.</p>
<p>Anche se i tagli dei tassi della Fed superano o superano le aspettative degli economisti di Goldman Sachs, Korpaty e il suo team ritengono che la Fed sia improbabile che raggiunga i cinque tagli dei tassi attualmente previsti dal mercato. Kolapati ha detto: “Crediamo che l’attuale scala delle politiche di fissazione dei prezzi e le aspettative preliminari possano essere state eccessive.” Se la loro valutazione è corretta, ciò potrebbe significare che molte fluttuazioni degli asset che si sono verificate nel mese scorso potrebbero almeno essere parzialmente tranquillizzate.</p>
<p>Oltre agli analisti di Goldman Sachs, anche altre banche d’investimento di Wall Street stanno fornendo ai clienti consigli su come trarre profitto dai tagli dei tassi di interesse valutati erroneamente. Ad esempio, Charlie McElligott, esperto di mercato in derivati ​​Nomura, ha menzionato anche negoziazioni simili nel suo rapporto di lunedì.</p>
<p>Nel rapporto, ha sottolineato che l’attività economica e l’inflazione potrebbero accelerare nuovamente, il che potrebbe compromettere le speranze degli investitori di tagli dei tassi di interesse. Ha proposto che la copertura di questo rischio potrebbe comportare la vendita di opzioni call sui tassi di interesse, simile al trading suggerito da Goldman Sachs. McLegort suggerisce anche un sentiment rialzista verso il dollaro statunitense e scommesse su note di valore ciclico (come l’energia) anziché azioni di crescita come le grandi aziende tecnologiche.</p>
<p>Va chiarito che questo stratega di Nomura non consiglia agli investitori di farne una parte fondamentale della loro strategia, almeno per ora. Al contrario, ha visto solo opportunità per l’hedging e “molte poche persone lo tengono”.</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 indicato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>