Tm90aXppZSBxdW90aWRpYW5lIHwgU3RhcmtuZXQgZmFyw6AgdW4gQWlyZHJvcCBzdGFzZXJhOyB1bmEgcGFydGUgZGVpIGZvbmRpIEVURiBkZWxsJ29ybyBwb3RyZWJiZSBlc3NlcmUgZmx1aXJlIGluIEJUQzsgTCdhZmZsdXNzbyBkaSBmb25kaSBoYSByYWdnaXVudG8gdW4gcmVjb3JkIHN0b3JpY28gbGEgc2V0dGltYW5hIHNjb3JzYQ=

2024-02-20, 04:24

<p><img src="https://gimg2.gateimg.com/image/article/17084030271_13.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Starknet20far20airdrop20stasera20Parte20dei20fondi20ETF20delloro20potrebbe20essere20fluire20in20Bitcoin49348"><a name="Crypto Daily Digest: Starknet farà airdrop stasera, Parte dei fondi ETF dell’oro potrebbe essere fluire in Bitcoin" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Starknet farà airdrop stasera, Parte dei fondi ETF dell’oro potrebbe essere fluire in Bitcoin</h2><p>Analizziamo gli ultimi sviluppi tra le autorità di regolamentazione in vari paesi. Secondo Bloomberg, il governo britannico prevede di approvare nuove normative per gestire stablecoin e servizi di staking di asset crittografici nei prossimi sei mesi.</p>
<p>Il segretario al Tesoro britannico per l’Economia, Bim Afolami, ha dichiarato ieri in un evento del settore che il governo britannico sta “promuovendo vigorosamente” la legislazione. Ha detto: “Speriamo di completare queste cose il prima possibile. Penso che queste cose siano fattibili nei prossimi sei mesi”.</p>
<p>Il Tesoro del Regno Unito ha fatto il suo primo impegno nell’ottobre dello scorso anno per fornire informazioni più chiare su specifiche aree delle criptovalute in qualche momento nel 2024. Tuttavia, le regole più ampie che governano gli scambi di criptovalute sono ancora in sospeso. Quando gli è stato chiesto se le linee guida potessero diventare anche leggi quest’anno, Afolami ha dichiarato di non poter fornire una tabella di marcia.</p>
<p>Secondo Coinpost, il Ministero giapponese dell’Economia, del Commercio e dell’Industria ha recentemente annunciato che il Gabinetto giapponese ha approvato una proposta per aggiungere la criptovaluta all’elenco degli asset che le partnership limitate di investimento locali possono acquisire o detenere.</p>
<p>Se la revisione della legge viene attuata, il venture capital (VC) giapponese potrà investire in progetti che emettono solo valute virtuali, e la soglia per le società <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> giapponesi per raccogliere fondi e condurre affari sarà abbassata. In precedenza, le società di venture capital giapponesi non potevano investire direttamente in criptoattività. Il governo giapponese presenterà un progetto di emendamento alla legge LPS alla Dieta nazionale già nel 2024.</p>
<p>Secondo NFT Gators, il gigante dell’e-commerce eBay ha tagliato oltre il 30% del suo team Web3, alimentando speculazioni secondo cui potrebbe chiudere la sua attività NFT. Nel giugno 2022, dopo l’acquisizione da parte di eBay di KnownOrigin nel mercato NFT, ha cambiato la sua strategia Web3. Stef Jay, responsabile di Business e Strategia, si è dimesso e la relazione con KnownOrigin è peggiorata. L’azienda ha sospeso tutti i programmi di arte digitale e c’è stato un aumento delle critiche interne nei confronti del team di leadership e strategico. In un mercato al ribasso nel mercato crittografico, il futuro dell’attività NFT di eBay è incerto.</p>
<p>La Fondazione Starknet ha annunciato sulla piattaforma X che i token STRK saranno disponibili per il ritiro alle 20:00 ora di Pechino del 20 febbraio 2024. Sono state apportate le correzioni necessarie all’allocazione dei token STRK dopo aver ricevuto feedback dalla comunità:</p>
<ol>
<li><p>Fissato circa 900 <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> principal stakers con più validatori (erroneamente calcolati per utilizzare solo un validator) che riceveranno un totale di circa 6,5 milioni di STRK;</p>
</li><li><p>Rated.network ha aggiornato il suo modello di classificazione degli staker in base ai feedback della comunità, con il risultato che oltre 6,9 milioni di STRK sono stati distribuiti a oltre 1000 staker individuali precedentemente etichettati erroneamente.</p>
</li><li><p>Corretto il problema che ha comportato l’iscrizione di circa 1.900 gesti GitHub, che è cambiata dopo aver preso degli snapshot e sono stati registrati preventivamente dopo gli annunci regolamentari. Oltre 1 milione di STRK sono stati salvati per potenziali future allocazioni comunitarie;</p>
</li><li><p>Su StarkEx, la differenza che consente alle società di hosting di presentare richieste basate su circa 200.000 chiavi utente è stata rimossa e verrà istituito un processo per consentire a questi utenti di riceverle in futuro. Queste correzioni verranno applicate domani.</p>
</li></ol>
<p>Secondo <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Secondo la divulgazione dei dati di Bloomberg di Munger, vari ETF sull’oro hanno avuto deflussi di circa $3 miliardi dall’inizio del 2024, mentre i prezzi dell’oro spot sono diminuiti del 3% quest’anno. D’altra parte, l’afflusso di ETF <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> ha raggiunto $4,1 miliardi e il tasso di crescita di Bitcoin spot ha raggiunto il 16% quest’anno. Parte di questo denaro potrebbe essere uscito dall’oro ed entrato nel mercato del Bitcoin.</p>
<p>Tuttavia, l’analisi suggerisce che sebbene Bitcoin abbia recentemente superato la soglia del trilione di dollari, questa tendenza non può ancora determinare un cambiamento fondamentale nelle preferenze degli investitori rispetto al mercato dell’oro da 13 trilioni di dollari.</p>
<p>Secondo il rapporto settimanale di CoinShares, l’afflusso di prodotti di investimento in asset digitali ha raggiunto la cifra storica di 2,45 miliardi di dollari la scorsa settimana. Finora quest’anno, l’afflusso ha raggiunto i 5,2 miliardi di dollari. Dal punto di vista regionale, gli Stati Uniti dominano, rappresentando il 99% degli afflussi, per un totale di 2,4 miliardi di dollari.</p>
<p>Bitcoin ha rappresentato oltre il 99% degli afflussi di capitale, e alcuni investitori hanno colto questa opportunità per aumentare le loro posizioni short in Bitcoin, portando a $5,8 milioni. <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha registrato un afflusso di $21 milioni. La recente chiusura di <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> ha influenzato il sentiment di mercato, causando un deflusso di 1,6 milioni di dollari in fondi. <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> Chainlink e <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygona</a> hanno ingressi di $1 milione, $900.000 e $900.000 rispettivamente, con continui ingressi settimanali fin dall’inizio di quest’anno.</p>
<p>Secondo il monitoraggio di Spot On Chain, Alameda Research attualmente detiene 25 milioni di WLD (del valore approssimativo di 167 milioni di dollari), corrispondenti a circa il 19% dell’offerta circolante. Questi $WLD sono stati ottenuti da Worldcoin il 15 agosto 2023, al prezzo di soli 1,78 dollari (circa 44,4 milioni di dollari), e questi token sono rimasti intatti fino ad oggi.</p>
<p>Secondo i dati di Scopescan, il valore totale degli asset crittografici detenuti presso gli indirizzi che iniziano con 0xc7c contrassegnati come ‘Teneo: Liquidazione 3AC’ è attualmente di 591 milioni di dollari. Detiene 75 milioni di token WLD, del valore approssimativo di 557 milioni di dollari, rappresentando il 94% dei suoi asset totali del portafoglio. Altri asset includono 8.437 milioni di DYDX, 5.75 milioni di USDC, 160.000 AXS e 101.98 ETH.</p>
<p>In precedenza, Zhu Su ha annunciato di aver investito in Worldcoin nel 2021, e i creditori di 3AC erano fra i più grandi detentori di posizioni di WLD.</p>
<p>Secondo gli ultimi dati di mercato di Gate.io, WLD viene attualmente quotato a $6.82, con un aumento del 8.26% nelle ultime 24 ore.</p>
<p>Recentemente, Lookonchain ha rilasciato dati di analisi sui token WLD, tra cui l’economia dei token, i principali detentori, la situazione finanziaria e la dinamica del denaro intelligente. L’offerta totale dei token WLD è di 10 miliardi (approssimativamente $74,71 miliardi), con un’offerta circolante di 130,76 milioni (approssimativamente $975,92 milioni, corrispondenti al 1,31% dell’offerta totale). Per quanto riguarda l’economia dei token, la distribuzione della comunità Worldcoin rappresenta il 75%, il team di sviluppo iniziale rappresenta il 9,8%, gli investitori TFH rappresentano il 13,5% e le riserve TFH rappresentano l’1,7%.</p>
<p>Per quanto riguarda i titolari di alto livello, i primi 10 detengono un totale di 9,15 miliardi di WLD (circa 70,6 miliardi di dollari), pari al 91,5% dell’offerta totale. Teneo, l’amministratore liquidatore di Three Arrows Capital, detiene 75 milioni di WLD (circa 579 milioni di dollari), pari allo 0,75% dell’offerta totale. Alameda: gli attivi in bancarotta di FTX detengono 25 milioni di WLD (circa 193 milioni di dollari), pari allo 0,25% dell’offerta totale. Per quanto riguarda la situazione finanziaria, Worldcoin ha raccolto un totale di 240 milioni di dollari in tre round di finanziamento.</p>
<p>In merito alla dinamica delle balene blu e dei soldi intelligenti, nella scorsa settimana tre balene hanno estratto un totale di 2,8 milioni di WLD (circa 21 milioni di dollari) da Binance e OKX. Inoltre, l’indirizzo dei soldi intelligenti che inizia con “0x0258” è molto bravo nell’acquistare WLD a prezzi bassi e venderli a prezzi alti. Il 1 novembre ha acquistato 267.062 WLD (circa 534.000 dollari) e le ha vendute il 19 dicembre, guadagnando 519.000 dollari (+97%). Il 12 gennaio ha acquistato 282.448 WLD (circa 784.000 dollari) e le ha vendute 16 ore fa, guadagnando 1,08 milioni di dollari (+137%).</p>
<h2 id="h2-Macro20chiusura20del20mercato20azionario20statunitense20oro20in20ripresa20e20previsioni20di20mercato20senza20tagli20dei20tassi20dinteresse780597"><a name="Macro: chiusura del mercato azionario statunitense, oro in ripresa e previsioni di mercato senza tagli dei tassi d’interesse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: chiusura del mercato azionario statunitense, oro in ripresa e previsioni di mercato senza tagli dei tassi d’interesse</h2><p>Lunedì, l’indice del dollaro statunitense ha raggiunto un nuovo massimo di 104,37 sul mercato statunitense per poi riprendersi i guadagni, chiudendo infine leggermente più basso a 104,25. Il mercato dei titoli di stato statunitensi era chiuso.</p>
<p>L’oro al contado ha continuato il suo slancio di ripresa dallo scorso venerdì e ha oscillato intorno al livello del 2020 nel corso della giornata, chiudendo infine in rialzo dello 0,23% a $2017,89 per oncia. L’argento al contado ha subito un forte calo dei prezzi dopo aver raggiunto un mercato ampio prima della sessione asiatica e ha chiuso infine in ribasso del 1,87% a $22,98 per oncia.</p>
<p>Mentre i trader valutano la situazione tesa in corso in Medio Oriente e il potenziale debole outlook della domanda, il prezzo internazionale del petrolio greggio fluttua e si mantiene ad un massimo di tre settimane. Il petrolio greggio WTI è salito dello 0,02% a $78,18 al barile; il petrolio greggio Brent è salito dello 0,07% a $83,38 al barile. Il mercato azionario statunitense è chiuso per un giorno a causa del President’s Day.</p>
<p>Scommettere sui tagli dei tassi di interesse è un tema principale per il 2024, ma con una serie di dati economici caldi che tengono la Federal Reserve vigile, il PIL degli Stati Uniti è aumentato del 3,3% nel quarto trimestre dello scorso anno, sono stati creati 353.000 nuovi posti di lavoro a gennaio e un tasso di inflazione del 3,1%. Questi dati hanno reso le politiche della Federal Reserve più complesse e hanno anche reso i mercati desiderosi di aspettare tagli ai tassi d’interesse inquieti.</p>
<p>I solidi dati delle ultime settimane hanno portato alcune persone sul mercato a porsi la domanda: quale impatto avrebbe se Powell e i suoi colleghi non tagliassero i tassi di interesse quest’anno, o almeno li mantenessero al di sopra delle aspettative di mercato?</p>
<p>In breve, anche se la possibilità di non abbassare i tassi di interesse è improbabile, indipendentemente dalla politica, il ciclo economico dovrebbe sostenere l’ascesa sostenuta delle azioni statunitensi, e il mercato azionario potrebbe rimanere forte, ma i bond potrebbero subire pesanti perdite.</p>
<p>Inoltre, un settore colpito dall’aumento dei tassi di interesse della Federal Reserve è l’immobiliare commerciale, e ogni ritardo nei tagli dei tassi prolungherà le sofferenze del settore. Quest’anno e oltre, i proprietari del settore immobiliare commerciale dovranno affrontare una grande quantità di scadenze del debito. In molti casi, i proprietari rifinanzieranno il loro debito a tassi di interesse più alti e valutazioni immobiliari più basse. Con la continuazione del lavoro da remoto e il forte calo del valore immobiliare, la situazione nel settore degli uffici è particolarmente brutta.</p>
<p>Il mese scorso, il miliardario immobiliare Barry Sternlicht ha dichiarato che il mercato degli uffici potrebbe subire perdite di 1 trilione di dollari.</p>
<p>Per quanto riguarda l’inflazione e il mercato del lavoro, gli analisti di Deutsche Bank affermano che se il tasso di inflazione raggiunge il 2,7% o superiore e il tasso di disoccupazione scende al di sotto del 4%, potrebbe mantenere la Federal Reserve su una posizione aggressiva.</p>
<p>I dati recenti riflettono questa situazione. A gennaio, l’IPC è aumentato del 3,1% su base annua, superiore alle aspettative. Anche i dati del PPI pubblicati lo scorso venerdì sono stati molto positivi. Prima di questo, l’ultimo rapporto sulle retribuzioni non agricole ha mostrato che i datori di lavoro statunitensi hanno aggiunto 353.000 posti di lavoro il mese scorso.</p>
<p>Tuttavia, Rosenberg ritiene che l’economia degli Stati Uniti non si surriscaldi nel 2024. Ha detto: ‘Dobbiamo essere più razionali. Possiamo solo dire che rispetto all’anno scorso, non vi è motivo per l’economia di accelerare nuovamente quest’anno. Con la crescita economica, il mercato può sopportare tassi d’interesse elevati, ma ulteriori aumenti dei tassi volti a frenare l’inflazione saranno più distruttivi.’</p>
<div class="blog-details-info"><br><div>Autore: <strong>Mashell C.</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 re-post dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>