Tm90aXppZSBxdW90aWRpYW5lIHwgQmxhc3QgTWFpbm5ldCB2YSBsaXZlOyBJbCBzZXR0b3JlIGRlaSBtZW1lIGhhIHJlZ2lzdHJhdG8gdW4gYXVtZW50byBnZW5lcmFsZSBkaSBvbHRyZSBpbCAyNSU7IExvIHN2aWx1cHBhdG9yZSBkaSBXTEQgYWNxdWlzaXNjZSBpbCBwb3J0YWZvZ2xpbyBTb2xhbmE=

2024-03-01, 04:20

<p><img src="https://gimg2.gateimg.com/image/article/17092676721_1.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Il20mainnet20di20Blast2020stato20lanciato20Le20meme20coin20sono20generalmente20aumentate20Lo20sviluppatore20di20Worldcoin20acquisisce20un20portafoglio20basato20su20Solana484704"><a name="Crypto Daily Digest: Il mainnet di Blast è stato lanciato; Le meme coin sono generalmente aumentate; Lo sviluppatore di Worldcoin acquisisce un portafoglio basato su Solana" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: Il mainnet di Blast è stato lanciato; Le meme coin sono generalmente aumentate; Lo sviluppatore di Worldcoin acquisisce un portafoglio basato su Solana</h2><p>Diamo un’occhiata alle attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Il 29 febbraio, i fondi GBTC di Grayscale sono usciti nuovamente in modo significativo, raggiungendo 599 milioni di dollari; Nel frattempo, l’afflusso di Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot ETF (FBTC) è stato di 44,8 milioni di dollari, l’afflusso di Bitwise Bitcoin spot ETF (BITB) è stato di 21,7 milioni di dollari ieri e l’afflusso di ARK 21Shares Bitcoin spot ETF (ARKB) è stato di 9,9 milioni di dollari ieri.</p>
<p>Eric Balchunas, analista senior ETF presso Bloomberg, ha affermato che l’aumento della domanda di Bitcoin causato dagli ETF, unito a una diminuzione dell’offerta disponibile, potrebbe innescare un ciclo speculativo a breve termine per gli asset digitali. “Potresti vivere un periodo di ascesa a spirale.”</p>
<p>Il mainnet di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> La rete di Layer 2 che genera interessi di Blast di Gate.io è stata ufficialmente lanciata. Prima di questo lancio, Blast aveva 180.000 utenti preventivi e un TVL di oltre 2,3 miliardi di dollari. Gli asset su questa piattaforma includono circa 469.000 ETH, 77,3 milioni di USDC, 67,1 milioni di USDT, 148.000 stETH e 24,7 milioni di DAI. Con il lancio della mainnet, gli utenti possono ora prelevare fondi.</p>
<p>Blast è stato creato da Tieshun Roquerre, fondatore di Blur nel mercato NFT, per fornire modelli di entrate nativi per <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> e stablecoin, con il primo che guadagna un interesse del 4% e il secondo che guadagna un interesse del 5%. Secondo il sito web della piattaforma, le prime visite alla piattaforma hanno accumulato oltre 180.000 membri della comunità e bloccato un valore totale (TVL) di oltre 2,3 miliardi di dollari.</p>
<p>Nel frattempo, SynFutures ha anche lanciato la sua piattaforma V3 sul mainnet di Blast e SynFutures ha lanciato un programma di ricompense a punti. Secondo fonti interne, SynFutures prevede di lanciare i suoi token nativi quest’anno.</p>
<p>SynFutures è un DEX focalizzato sul trading di future perpetui di criptovalute, che ha lanciato la sua ultima versione V3 su Ethereum e un programma di ricompense chiamato Oyster Odyssey. SynFutures ha dichiarato che gli utenti della sua versione V3 saranno anche idonei per l’imminente airdrop Blast.</p>
<p>Rachel Lin, co-fondatrice e CEO di SynFutures, ha dichiarato che gli utenti riceveranno punti doppi da Blast e Oyster Odyssey e il 100% degli airdrop per sviluppatori di Blast sarà restituito ai partecipanti. SynFutures ha raccolto circa $38 milioni in finanziamenti totali e ha ricevuto il sostegno di Pantera Capital, HashKey Capital e altri.</p>
<p>Nel trend laterale temporaneo di Bitcoin, il valore di mercato di Memecoin è aumentato di oltre il 27% nelle ultime 24 ore. Le principali Memecoin, come Dogebonk e Bonk, sono aumentate rispettivamente di circa il 34% e il 54%.</p>
<p>Il giornalista dei dati di Nansen, Martin Lee, ha affermato che il crescente sentimento di rischio ha spinto l’ultimo aumento del mercato dei Memecoin. “Bitcoin si sta avvicinando rapidamente al suo massimo storico precedente”, ha detto Lee a The Block. “Man mano che i rischi di mercato aumentano, il capitale inizierà a… <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> verso token più speculativi e i meme sono la scelta più adatta.”</p>
<p>Il principale sviluppatore di Worldcoin, Tools For Humanity, ha acquisito Ottr Finance, una startup di portafogli digitali con sede su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>. Questa acquisizione sembra essere almeno in parte mirata ad aiutare Worldcoin a attrarre nuovi utenti, molti dei quali sono nuovi a web3, e Worldcoin fornirà loro servizi di portafoglio.</p>
<p>WLD è un progetto di “prova di personalità” che utilizza dispositivi sferici per scansionare l’iride di una persona e determinare che essa è una persona unica, per poi fornirle dei token crittografici. Secondo il sito web di World Coin, ci sono quasi 3,9 milioni di persone registrate.</p>
<p>Ottr Finance ha dichiarato che chiuderà i portafogli basati su <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> e li integrerà in Tools for Humanity per aiutare Worldcoin a realizzare la sua missione. Ottr ha dichiarato in un comunicato: “Abbiamo appreso rapidamente come aiutare Worldcoin a stabilire la più grande rete umana al mondo per migliorare la fiducia online nell’era dell’intelligenza artificiale e del valore dell’ingresso nell’economia globale.”</p>
<p>Dalla sua fondazione, il portafoglio di Ottr Finance ha lanciato funzionalità come l’integrazione senza soluzione di continuità con i conti bancari statunitensi, i trasferimenti e le transazioni senza costi di gas e il backup cloud senza password. La facile integrazione con la Bank of America potrebbe aiutare Tools for Humanity in futuro.</p>
<h2 id="h2-Tendenze20di20mercato20il20leverage20di20liquidazione20di20mercato20BTC20si20riduce20lETF20spot20continua20ad20acquistare414463"><a name="Tendenze di mercato: il leverage di liquidazione di mercato BTC si riduce, l’ETF spot continua ad acquistare" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: il leverage di liquidazione di mercato BTC si riduce, l’ETF spot continua ad acquistare</h2><p>Secondo i dati di mercato di Gate.io, i prezzi del BTC stanno vivendo una normale correzione dei prezzi. Il mercato ha iniziato a eliminare la leva finanziaria, con una leggera diminuzione dei tassi contrattuali, e l’importo complessivo delle liquidazioni ha raggiunto i 350 milioni di dollari, con l’obiettivo principale delle liquidazioni che è il rincorrere posizioni al rialzo. Allo stesso tempo, il mercato azionario statunitense ha mostrato un trend al rialzo. Anche se i dati sull’inflazione sono ancora cresciuti mensilmente, hanno soddisfatto le aspettative.<br><img src="https://gimg2.gateimg.com/image/article/17092670571.png" alt=""><br>Origine: Coinglass</p>
<p>I dati di ieri hanno mostrato che un totale di 8 ETF hanno aumentato le loro partecipazioni di 14.934 BTC, equivalenti a circa 940 milioni di dollari, mentre Grayscale ha ridotto solo le sue partecipazioni di 2.223 BTC, equivalenti a circa 139,8 milioni di dollari. In particolare, BlackRock ha aumentato le sue partecipazioni di 10.140 BTC, circa 638 milioni di dollari, mentre Fidelity ha aumentato le sue partecipazioni di 4.066 BTC, circa 255,9 milioni di dollari.<br><img src="https://gimg2.gateimg.com/image/article/17092670752.png" alt=""><br>Sorgente: Lookonchain</p>
<h3 id="h3-Dinamica20Web3755971"><a name="Dinamica Web3:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dinamica Web3:</h3><ol>
<li><p>Dopo il lancio della mainnet di Blast, il TVL (valore totale bloccato) ha superato i 2 miliardi di dollari, secondo solo ai 3 miliardi di Arbitrum, con oltre 150.000 indirizzi attivi. Secondo le notizie ufficiali, il 50% degli airdrop di Blast sarà assegnato agli utenti di Blast point, mentre il restante 50% sarà assegnato a Blast Dapp. Attualmente, il progetto più atteso sulla catena Blast è Yolo, che è probabilmente un progetto gemello dello scambio NFT LooksRare. L’ufficiale ha confermato che una parte significativa del token YOLO sarà assegnata ai futuri stakeholder del token LOOKS.</p>
</li><li><p>Inizio del terzo round di Blur: si sospetta che Blur stia affrontando il terzo round di BLUR SEASON 3.</p>
</li></ol>
<h3 id="h3-Punti20caldi20di20mercato584615"><a name="Punti caldi di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi di mercato:</h3><ol>
<li><p>I prezzi di SOL hanno raggiunto un nuovo massimo in due anni: dopo la consolidazione, SOL ha superato su base settimanale, raggiungendo un nuovo massimo da maggio 2022. Anche i progetti BONK, WIF, RAY e altri progetti dell’ecosistema Solana hanno seguito l’esempio. Gli afflussi di fondi statunitensi guidano principalmente questo mercato rialzista, quindi gli effetti di rimbalzo sui progetti statunitensi potrebbero essere più marcati.</p>
</li><li><p>Il concetto di AI continua ad essere caldo: progetti come FET e ARKM nel concetto di AI hanno registrato un significativo aumento, in linea con le previsioni precedenti. Come una nuova storia nell’industria, l’AI ha attirato maggiore attenzione degli utenti. Inoltre, la conferenza NVIDIA AI si terrà il 18 marzo e i token del concetto di AI potrebbero sperimentare un’ondata di popolarità prima e dopo la conferenza.</p>
</li><li><p>Grayscale sta mettendo pressione alla SEC: Grayscale sta mettendo pressione alla Securities and Exchange Commission (SEC) degli Stati Uniti per ottenere l’approvazione per il trading di opzioni ETF Bitcoin spot.</p>
</li></ol>
<p>Contemporaneamente alla correzione del BTC, il mercato ha mostrato varie dinamiche. Gli investitori dovrebbero monitorare attentamente le variazioni dei prezzi del BTC e adeguare prontamente le proprie strategie di investimento. Inoltre, i nuovi progetti e le zone calde del mercato nel campo <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> meritano anche attenzione, poiché potrebbero portare maggiori opportunità di investimento. Tuttavia, gli investimenti devono essere cauti e le risorse dovrebbero essere allocate in modo ragionevole in base alla tolleranza al rischio individuale.</p>
<h2 id="h2-Macro20I20dati20sullinflazione20rilasciati20i20mercati20azionari20globali20in20aumento20SampP2050020e20Nasdaq20raggiungono20nuovi20massimi20la20commissione20finanziaria20della20Camera20ha20deciso20di20annullare20lannuncio20della20custodia20della20SEC463098"><a name="Macro: I dati sull’inflazione rilasciati, i mercati azionari globali in aumento, S&amp;P 500 e Nasdaq raggiungono nuovi massimi; la commissione finanziaria della Camera ha deciso di annullare l’annuncio della custodia della SEC" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I dati sull’inflazione rilasciati, i mercati azionari globali in aumento, S&amp;P 500 e Nasdaq raggiungono nuovi massimi; la commissione finanziaria della Camera ha deciso di annullare l’annuncio della custodia della SEC</h2><p>Il 29 febbraio, Reuters ha riportato che gli indici S&amp;P 500 e Nasdaq hanno chiuso a livelli storici giovedì, mentre gli indici dei mercati azionari globali sono saliti giovedì. L’indice S&amp;P è salito del 5,17%, l’indice Nasdaq del 6,12% e l’indice Dow del 2,22%, tutti in crescita per il quarto mese consecutivo. I dati sull’inflazione negli Stati Uniti hanno tranquillizzato gli investitori e hanno contribuito a far diminuire i rendimenti dei titoli del tesoro statunitensi.</p>
<p>L’indice Nasdaq ha raggiunto un nuovo massimo di chiusura per la prima volta in più di due anni, mentre Wall Street ha fatto un rimbalzo dal calo della giornata di negoziazione precedente poiché gli investitori sono rimasti cauti in attesa del rilascio dei dati sull’indice dei prezzi dei consumatori personali (PCE) degli Stati Uniti, poiché i recenti dati sull’indice dei prezzi al consumo (CPI) e sull’indice dei prezzi alla produzione (PPI) hanno superato le aspettative.</p>
<p>Alla fine, l’indicatore di inflazione preferito dalla Federal Reserve, i dati PCE, ha mostrato il più piccolo aumento annuale dell’inflazione in quasi tre anni, consentendo di preservare la possibilità di un taglio dei tassi da parte della Federal Reserve a giugno. Il stratega di TD Wealth, Sid Vaidya, ha dichiarato: “La tendenza di mercato di oggi riflette effettivamente che non abbiamo visto un’accelerazione dell’inflazione, il che è un sollievo per noi. Questo ha influenzato i mercati dei titoli a reddito fisso e azionari.”</p>
<p>Secondo lo strumento FedWatch del CME, attualmente il mercato ritiene che la probabilità che la Federal Reserve riduca i tassi di interesse a giugno sia del 62%.</p>
<p>Per quanto riguarda i bond del tesoro, il rendimento del benchmark del bond del tesoro decennale è sceso di 0,6 punti base al 4,268% dal 4,274% di mercoledì scorso, mentre il rendimento del bond del tesoro a trent’anni è sceso di 2,2 punti base al 4,3884%. Il rendimento del bond del tesoro biennale è generalmente in linea con le aspettative dei tassi di interesse, mostrando il 4,6477%, essenzialmente invariato rispetto al 4,648% di mercoledì scorso.</p>
<p>Per quanto riguarda i prezzi dell’oro, l’oro ha raggiunto un massimo di un mese giovedì, poiché il dollaro americano è sceso dopo la pubblicazione dei dati sull’inflazione attesa negli Stati Uniti. Gli operatori hanno rivolto la loro attenzione a ulteriori commenti da parte dei funzionari della Federal Reserve alla ricerca di indizi sui tagli dei tassi di interesse. L’oro spot ha riportato 2.045,59 dollari per oncia, in aumento dello 0,5%. I futures statunitensi sono aumentati dello 0,6% a 2.054,40 dollari.</p>
<p>In termini di materie prime, i prezzi del petrolio sono scesi dopo che i dati statunitensi hanno inviato segnali complessi sulle prospettive della domanda di petrolio greggio nelle principali economie mondiali. I prezzi del petrolio greggio statunitense sono scesi dello 0,36% a $78,26 al barile, mentre i prezzi del petrolio greggio Brent sono scesi dello 0,07% a $83,62 al barile.</p>
<p>La commissione per i servizi finanziari della Camera ha votato giovedì durante un rialzo dei prezzi per abrogare la dichiarazione contabile dei dipendenti della SEC n. 121 (SAB 121), che richiede alle aziende che detengono criptovalute di registrare i propri clienti come passività nei loro bilanci. L’industria delle criptovalute è preoccupata che ciò possa influire sulle banche che forniscono servizi di custodia per gli asset digitali.</p>
<p>Il deputato del Nebraska Mike Flood, che ha proposto la risoluzione, ha dichiarato che per le banche, gli asset di custodia, inclusi i titoli, sono sempre considerati elementi ‘fuori bilancio’ e ‘le conseguenze di richiedere alle banche di detenere questi asset nei loro bilanci sono molto serie’.</p>
<p>“Se una banca affida asset digitali in base a SAB 121, l’elaborazione sul suo bilancio influirà sulle sue altre obbligazioni regolamentari, come i requisiti di capitale e liquidità. Il risultato finale è che la banca deve scegliere di affidare asset digitali, esagerando il suo bilancio e influenzando seriamente tutte le altre linee di business, o uscire completamente dal mercato.”</p>
<p>Flood ha anche affermato che SAB 121 potrebbe influire sugli exchange-traded fund Bitcoin in contanti e le banche non potranno diventare custodi di questi ETF.</p>
<p>I membri della Camera dei rappresentanti hanno approvato questo disegno di legge con 31 voti a favore e 20 contrari, ma il disegno di legge deve ancora essere sottoposto alla sessione plenaria della Camera dei rappresentanti e, infine, al Senato per la revisione. Secondo la legge, questa notifica deve essere esaminata dal Congresso prima di entrare in vigore, quindi si prevede che i legislatori discuteranno il SAB 121 nel 2024.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S.</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, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div></div>