Tm90aXppZSBnaW9ybmFsaWVyZSB8IEJUQyBoYSBpbCAyMCUgZGkgcHJvYmFiaWxpdMOgIGRpIHN1cGVyYXJlIGkgNzAuMDAwIGRvbGxhcmkgZW50cm8gbGEgZmluZSBkaSBhcHJpbGU7IGdsaSB1dGVudGkgYXR0aXZpIGdpb3JuYWxpZXJpIGRlbGwnQVBQIG1vbmRpYWxlIGhhbm5vIHN1cGVyYXRvIDEgbWlsaW9uZTsgb2x0cmUgNDAwIG1

2024-02-19, 06:54

<p><img src="https://gimg2.gateimg.com/image/article/17083254871_12.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20Honduras20vieta20il20trading20di20criptovalute20i20token20AVAX20ID20e20DYDX20saranno20sbloccati20in20grandi20quantit20questa20settimana724508"><a name="Riassunto giornaliero delle criptovalute: Honduras vieta il trading di criptovalute, i token AVAX, ID e DYDX saranno sbloccati in grandi quantità questa settimana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: Honduras vieta il trading di criptovalute, i token AVAX, ID e <a href="/price/dydx-dydx" target="_blank" class="blog_inner_link">DYDX</a> saranno sbloccati in grandi quantità questa settimana</h2><p>Secondo Reuters, la Banca Nazionale e la Commissione per i Titoli e le Borse di Honduras hanno annunciato in una risoluzione di aver vietato al sistema finanziario del paese di scambiare criptovalute e asset virtuali simili, a causa dei rischi di frode e riciclaggio di denaro, con effetto immediato. La risoluzione è prevista per il prossimo lunedì ma sarà annunciata questo venerdì. La risoluzione vieta alle istituzioni sotto la sua supervisione di “mantenere, investire, intercedere o scambiare criptovalute, asset crittografici, valute virtuali, token o qualsiasi altro asset virtuale simile non emesso o autorizzato dalla banca centrale.”</p>
<p>Attualmente, non esiste alcuna regolamentazione degli asset crittografici secondo la legge honduregna, anche se le piattaforme per il trading di asset crittografici operano nel paese. Le autorità regolamentari sottolineano che a causa del fatto che molte di queste piattaforme sono registrate in molte giurisdizioni, la legge honduregna non può controllarle e possono “partecipare ad attività di frode, riciclaggio di denaro e finanziamento del terrorismo”. La Banca Centrale dell’Honduras ha avvertito che non è responsabile di tali transazioni e non può garantire tali transazioni.</p>
<p>All’inizio di gennaio è stato riferito che la Zona Economica Speciale di Prospera in Honduras ha riconosciuto <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> come unità di conto. Al momento non è chiaro quale impatto avrà la nuova politica su questa zona economica speciale.</p>
<p>Pixels ha annunciato che distribuirà un totale di 20 milioni di token PIXEL agli stakeholder di RON, da distribuire in due fasi: il primo lotto di 10 milioni di token è già iniziato e il secondo lotto sarà distribuito entro un mese. La data di snapshot è fissata per l’8 febbraio alle 10:00. In base al numero di RON scommessi dagli utenti, vengono suddivisi in quattro livelli e l’importo totale delle ricompense PIXEL ottenute per ogni livello è il seguente: 1 RON: ottenuti 183,34 PIXEL; 55 RON: ottenuti 675,75 PIXEL; 684,64 RON: ottenuti 2315,77 PIXEL; 8317,4 RON: ottenuti 3955,11 PIXEL.</p>
<p>L’importo sopra rappresenta l’importo totale che può essere richiesto per ogni livello, e gli utenti possono richiederne la metà oggi. Per ricevere la seconda parte della ricompensa, gli utenti devono mantenere il livello di idoneità corrispondente. Si noti che il periodo di validità per due richieste è di 3 mesi dalla data della prima idoneità. La ricompensa PIXEL sarà inviata all’email di gioco dell’utente, e il processo di richiesta potrebbe richiedere fino a 1 ora.</p>
<p>Secondo i dati di DeBank, il valore totale degli asset corrente del contratto di rete Layer 2 Blast lanciato dal fondatore di Blur Pacman ha superato i 1,8 miliardi di dollari, raggiungendo 1.801.943.043 dollari. Circa 1,64 miliardi di dollari di ETH sono stati depositati nel protocollo Lido, 158.785.614 dollari di asset sono stati depositati nel protocollo Maker e 7.798.249 dollari di asset sono stati trattenuti nel portafoglio.</p>
<p>Secondo i dati giornalieri di Ark Invest, Cathie Wood’s ARK Invest ha venduto 499.149 azioni COIN (Coinbase Global Inc) il 16 febbraio. Tra queste, ARKK Fund ha venduto 397.924 azioni; ARKW Fund ha venduto 45.433 azioni; e ARKF Fund ha venduto 55.792 azioni. Calcolato al prezzo di chiusura di circa $180 per azione in quel giorno, il valore totale è di circa $90 milioni.</p>
<p>Il post ufficiale di Worldcoin ha affermato che gli utenti attivi giornalieri dell’app World hanno superato 1 milione questa settimana. Alla fine dell’anno scorso, è stato riferito che il numero di utenti di WorldAPP ha superato i 5 milioni, con oltre 2,7 milioni di persone che possiedono World IDs.</p>
<p>Secondo i dati di Coinglass, la posizione aperta attuale nei contratti futures <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> in tutta la rete è di 458.600 BTC (circa 23,72 miliardi di dollari). Il Chicago Mercantile Exchange (CME) ha un record di 130.710 BTC (circa 6,75 miliardi di dollari) in contratti futures Bitcoin aperti, occupando il primo posto; La posizione aperta del contratto Bitcoin di Binance è di 112.950 BTC (circa 5,84 miliardi di dollari), al secondo posto.</p>
<p>Secondo i dati di Lyra, il protocollo di opzioni DeFi, i trader di criptovalute ritengono che la probabilità che Bitcoin superi i $70.000 entro la fine di aprile sia del 20%. Lyra ha recentemente lanciato opzioni che scadono il 26 aprile, consentendo ai trader di speculare sulle tendenze dei prezzi prima e dopo la riduzione delle ricompense di Bitcoin. Bitcoin è salito del 35% nelle ultime tre settimane, raggiungendo $52.000, il livello più alto dal termine del 2021, dimostrando un forte slancio al rialzo.</p>
<p>Secondo i dati di Token Unlocks, token come AVAX, ID e DYDX esperimenteranno uno sblocco unico di grandi dimensioni questa settimana, con un valore totale di rilascio di oltre $400 milioni. Tra di essi:</p>
<p>Alle 0:00 (UTC) del 22 febbraio, AVAX ( <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>) sbloccerà 9,54 milioni di token del valore di circa 383 milioni di dollari, corrispondenti al 2,6% dell’offerta circolante;</p>
<p>Alle 0:00 (UTC) del 22 febbraio, SPACE ID sbloccherà 18,49 milioni di token GAL, del valore approssimativo di $10,73 milioni, pari al 4,29% dell’offerta circolante;</p>
<p>Alle 15:00 (UTC) del 20 febbraio, DYDX ( <a href="/price/dydx-dydx" rel="nofollow noopener noreferrer" target="_blank">dYdX</a>) sbloccherà 575.000 token del valore approssimativo di 1,78 milioni di dollari, corrispondente al 0,19% della fornitura circolante; Questa settimana sono stati sbloccati complessivamente 2,16 milioni di token, del valore di 682 dollari, pari allo 0,72% della fornitura circolante.</p>
<p>Inoltre, ACA (Acala) e <a href="/price/1inch-1inch" rel="nofollow noopener noreferrer" target="_blank">1inch</a>(1INCH) riceverà anche lo sblocco dei token del valore di centinaia di migliaia di dollari questa settimana. STRK (Starknet) riceverà il rilascio/distribuzione dei token alle 8:00 del mattino del 20 febbraio.</p>
<h2 id="h2-Macro20il20PPI20supera20le20aspettative20con20una20probabilit20del209020di20non20ridurre20i20tassi20dinteresse20a20marzo915034"><a name="Macro: il PPI supera le aspettative, con una probabilità del 90% di non ridurre i tassi d’interesse a marzo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: il PPI supera le aspettative, con una probabilità del 90% di non ridurre i tassi d’interesse a marzo</h2><p>Il tema di mercato della settimana scorsa è rimasto il deterioramento delle aspettative di tagli dei tassi di interesse. Dopo che i dati hanno mostrato che l’inflazione degli Stati Uniti non si è raffreddata così rapidamente come gli investitori speravano, i trader sono stati costretti a continuare a ridurre le loro scommesse sui tagli dei tassi della Federal Reserve, con il primo taglio dei tassi previsto per essere rinviato fino a giugno. Lo swap dei tassi di interesse mostra che il prezzo di mercato attuale per il taglio dei tassi della Federal Reserve nel 2024 è inferiore a 90 punti base, vicino alla mediana di 75 punti base prevista dai responsabili delle politiche, rispetto all’aspettativa di 150 punti base all’inizio di febbraio.</p>
<p>Gli investitori comprenderanno ulteriormente le opinioni degli investitori sulle politiche riguardanti il percorso dei tagli ai tassi di interesse dai verbali della riunione di giovedì del Comitato federale per il mercato aperto (FOMC). Nella stessa giornata, la Banca centrale europea rilascerà i verbali della sua riunione sul tasso di interesse. Inoltre, questa settimana ci sarà un fitto rilascio di dati PMI da vari paesi.</p>
<p>Venerdì scorso, tutti gli indicatori PPI hanno superato le aspettative, con il PPI degli Stati Uniti che è aumentato del 0,9% su base annua e dello 0,3% su base mensile a gennaio, entrambi oltre le aspettative. La possibilità che la Federal Reserve riduca i tassi di interesse a maggio e giugno è diminuita nella definizione dei contratti di swap. Ciò significa che i dati PCE tra due settimane sono anche probabili che si riprendano, aumentando così l’aspettativa che la Federal Reserve non riduca presto i tassi di interesse, poiché i responsabili politici sono preoccupati che tagli prematuri dei tassi possano innescare un aumento dell’inflazione.</p>
<p>Ian Lyngen di BMO Capital Markets ha sottolineato che l’IPP è un dato “inquietante” che rafforza il tono stabilito dal CPI di base. L’ex Segretario al Tesoro Lawrence Summers ha affermato che la pressione inflazionistica apparentemente sostenuta nei dati più recenti suggerisce che la prossima mossa di politica della Federal Reserve è più probabile che sia un aumento dei tassi piuttosto che un taglio dei tassi.</p>
<p>Dalla scorsa riunione, la maggior parte dei funzionari della Federal Reserve ha espresso pazienza riguardo ai cambiamenti dei tassi di interesse e ha messo in guardia contro tagli prematuri dei tassi, considerato il forte momentum dell’economia statunitense. Se i verbali della riunione rifletteranno un tono simile con più decisori politici, il dollaro statunitense potrebbe guadagnare ulteriore slancio verso l’alto. Con l’attenuarsi delle aspettative di tagli dei tassi di interesse, l’indice del dollaro statunitense è salito del 3% finora quest’anno.</p>
<p>A causa del indebolimento delle prospettive di taglio dei tassi d’interesse della Federal Reserve a causa dei dati sull’inflazione PPI, l’indice del dollaro degli Stati Uniti ha raggiunto un massimo intraday durante la negoziazione, ma ha rapidamente recuperato tutti i guadagni prima di chiudere vicino a 104,275. Il rendimento del titolo del Tesoro degli Stati Uniti a 10 anni ha raggiunto brevemente il livello del 4,3% e poi è sceso, chiudendo alla fine al 4,281%. Il rendimento del titolo del Tesoro degli Stati Uniti a 2 anni, sensibile ai tassi di interesse, è salito brevemente di oltre 10 punti base, raggiungendo il punto più alto dell’anno. I guadagni alla fine della giornata erano leggermente più alti, chiudendo infine al 4,644%.</p>
<p>L’oro spot è crollato di quasi $10 nel breve termine dopo la pubblicazione dei dati del PPI di gennaio negli Stati Uniti, poi si è ripreso e alla fine ha chiuso in rialzo dello 0,44% a $2013,23 l’oncia, ma ha comunque registrato due letture settimanali negative consecutive; L’argento spot è salito con forza dopo essersi stabilizzato a quota 23, chiudendo infine in rialzo del 2,14% a $23,42 l’oncia.</p>
<p>Inoltre, le tensioni in aumento in Medio Oriente hanno mascherato la diminuzione delle speranze di tagli dei tassi di interesse e le previsioni di domanda poco promettenti per quest’anno, con il petrolio greggio internazionale in aumento per due settimane consecutive, raggiungendo un nuovo massimo in quasi tre settimane. Il petrolio greggio WTI è salito dello 0,81% a $78,16 al barile; il petrolio greggio Brent è salito dello 0,58% a $83,22 al barile. I tre principali indici azionari statunitensi hanno chiuso leggermente al ribasso. Al termine della sessione, il Dow Jones Industrial Average è sceso dello 0,37%, il Nasdaq è sceso dell’0,82% e l’indice S&amp;P 500 è sceso dello 0,49%.</p>
<p>Recentemente, diversi funzionari della Federal Reserve hanno espresso le loro opinioni, tra cui il presidente della Fed di Atlanta, Bostic, ha dichiarato di essere incline a iniziare a tagliare i tassi di interesse in estate e si aspetta comunque due tagli dei tassi nel 2024; il presidente della Fed di Richmond, Barkin, ritiene che i dati del CPI confermino il motivo per cui la Federal Reserve ha bisogno di maggiore fiducia nei tagli dei tassi di interesse.</p>
<p>Inoltre, il presidente della Fed di San Francisco Daley ha dichiarato che tre tagli dei tassi sono un punto di riferimento ragionevole per quest’anno, e anche l’ex “sostenitore falco” Brad della Fed ritiene che i tagli dei tassi di marzo siano saggi.</p>
<p>Secondo il Federal Reserve Watch del CME, la probabilità che la Federal Reserve mantenga i tassi di interesse nell’intervallo del 5,25% - 5,50% a marzo è del 90%, mentre la probabilità di un taglio dei tassi di 25 punti base è del 10%. La probabilità di mantenere stabili i tassi di interesse entro maggio è del 61,6%, la probabilità di un taglio cumulativo di 25 punti base è del 35,2%, mentre la probabilità di un taglio cumulativo di 50 punti base è del 3,2%.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Byron B.</strong>, Ricercatore 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>