Tm90aXppZSBnaW9ybmFsaWVyZSB8IFByb2dldHRvIERyaWZ0IExhbmNpYXRvIDEwME0gVG9rZW4gQWlyZHJvcHM7IEF2YWxhbmNoZSBoYSBsYW5jaWF0byBsYSB0b2tlbml6emF6aW9uZSBIRUxPQyBzdWxsYSBjYXRlbmE7IEkgZGV0ZW50b3JpIGRpIEFHSVggaGFubm8gdm90YXRvIHN1bGxhIHByb3Bvc3RhIGRpIEFTSQ==

2024-04-17, 04:12

<p><img src="https://gimg2.gateimg.com/image/article/171332695417.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20il20progetto20Solana20Drift20ha20lanciato2010020milioni20di20token20airdrop20Avalanche20ha20lanciato20la20tokenizzazione20HELOC20sulla20blockchain20proposta20dellAlleanza20Super20Intelligenza20Artificiale20ASI20approvata20dai20detentori20di20AGIX413473"><a name="Riepilogo giornaliero delle criptovalute: il progetto Solana Drift ha lanciato 100 milioni di token airdrop; Avalanche ha lanciato la tokenizzazione HELOC sulla blockchain; proposta dell’Alleanza Super Intelligenza Artificiale ASI approvata dai detentori di AGIX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: il progetto <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> Drift ha lanciato 100 milioni di token airdrop; <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> ha lanciato la tokenizzazione HELOC sulla blockchain; proposta dell’Alleanza Super Intelligenza Artificiale ASI approvata dai detentori di AGIX</h2><p>In primo luogo, esaminiamo l’attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF spot. Secondo i dati di Farside Investor, il 16 aprile i fondi GBTC di Grayscale sono usciti per 79,4 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 1,4 milioni di dollari, mentre l’uscita di ARK 21 Shares Bitcoin spot ETF (ARKB) è stata di 12,9 milioni di dollari.</p>
<p>La recente situazione economica e politica tesa ha portato gli investitori a propendere per l’avversione al rischio, con un significativo calo del mercato delle criptovalute e una conseguente fuoriuscita netta di fondi dagli ETF. Tuttavia, anche se Bitcoin è colpito, rimane la criptovaluta più performante, con la dominanza di mercato di Bitcoin che raggiunge il suo livello più alto da aprile 2021.</p>
<p>DEX Deriva su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> sta per lanciare il suo token di governance DRIFT airdrop. Drift ha annunciato martedì che l’offerta totale di token DRIFT è di 1 miliardo, di cui il 10% (o 100 milioni) sarà distribuito tramite airdrop. Questi 100 milioni di token saranno distribuiti in base alle attività degli utenti sulla piattaforma Drift e si prevede che copriranno 180.000 utenti.</p>
<p>Drift è stato lanciato su Solana nel 2021 ed è uno dei primi progetti DeFi sulla blockchain. Da allora, ha facilitato un volume cumulativo delle transazioni di oltre $20 miliardi. Attualmente, il TVL ha superato i $250 milioni.</p>
<p>Tutti i token DRIFT saranno allocati entro cinque anni, di cui oltre il 50% assegnato alla comunità. In particolare, le comunità e gli ecosistemi riceveranno il 53% dei token, il 25% per lo sviluppo del protocollo e il 22% per i partecipanti strategici.</p>
<p>Si segnala che Drift ha effettuato più snapshot negli ultimi tre anni e ha condotto un’analisi approfondita delle attività relative agli airdrop di token.</p>
<p>La rete AI centralizzata SingularityNET ha annunciato sulla piattaforma X che la maggior parte dei detentori di token AGIX ha approvato la proposta dell’Alleanza dell’Intelligenza Artificiale Superiore (ASI).</p>
<p>Rapporti precedenti hanno mostrato che SingularityNET, <a href="/price/fetch-ai-fet" rel="nofollow noopener noreferrer" target="_blank">Fetch.ai</a>, e Ocean Protocol hanno annunciato la creazione dell’Artificial Superintelligence Alliance. Creare la più grande rete decentralizzata open-source unendo miliardi di token.</p>
<p>In questa alleanza, i token $FET, $OCEAN e $AGIX utilizzati dalle tre reti dei membri dell’alleanza saranno fusi in un unico token $ASI, che verrà utilizzato nella rete decentralizzata di intelligenza artificiale fusa, fornendo una scala e capacità senza precedenti. Secondo il piano di fusione, si prevede che il valore di mercato dei token ASI dopo una diluizione completa raggiungerà i $7,5 miliardi.</p>
<p>Il protocollo di tokenizzazione della linea di credito garantita da casa (HELOC) di Homium ha annunciato di aver completato un round di finanziamento da $10 milioni guidato da Sorenson Impact Group e Blizzard.</p>
<p>Secondo la sua dichiarazione ufficiale, Homeum si basa sul <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a> blockchain, consentendo ai proprietari di casa di prendere in prestito contro il valore netto della loro proprietà senza aumentare il loro debito mensile. Utilizzando Homeum, i proprietari di casa possono utilizzare una parte del valore futuro della loro proprietà come garanzia per il loro equità di prestito.</p>
<p>Nel frattempo, gli investitori riceveranno un asset tokenizzato che può tracciare l’apprezzamento del prezzo delle piscine di case condivise sulla piattaforma Homeum. Il servizio iniziale di prestito immobiliare tokenizzato sarà fornito in Colorado, USA.</p>
<p>Citibank descrive la tokenizzazione come il prossimo “killer use case” per le criptovalute e crede che entro il 2030, la dimensione della tokenizzazione degli asset nel mondo reale potrebbe raggiungere i 5 trilioni di dollari.</p>
<h2 id="h2-Tendenze20di20mercato532142"><a name="Tendenze di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato</h2><p>Il mercato mostra una tendenza debole e volatile, con Bitcoin che torna da $62.000 ieri sera a circa $64.000. A meno di tre giorni dall’evento di halving di Bitcoin, mentre gli ETF spot hanno registrato deflussi netti per due giorni consecutivi. Per quanto riguarda la macroeconomia, anche il mercato azionario statunitense ha sperimentato volatilità, con l’indice del dollaro statunitense che ha raggiunto un nuovo massimo in quasi sei mesi. Il discorso di Powell, ancora una volta, ha scatenato aspettative di tagli dei tassi di interesse.</p>
<h3 id="h3-Punti20caldi20del20mercato99943"><a name="Punti caldi del mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi del mercato</h3><p>La blockchain modulare TIA sta crescendo in controtendenza: il tasso di staking di TIA ha raggiunto il 67%, e il prossimo sblocco su larga scala avverrà in ottobre, sei mesi dopo. Questo tipo di valuta sub-nuova ha una buona struttura di chip ed è facilmente soggetta al controllo di mercato.</p>
<p>I token del settore delle monete dei fan stanno salendo: i token nei settori delle monete dei fan come SANTOS, PSG e OG stanno salendo. La partita di calcio della Coppa Europea sta per iniziare e il mercato sta alimentando i token concettuali correlati.</p>
<p>Le prime valute forti hanno compensato le perdite: ENA, PENDLE, CKB e altre hanno compensato le perdite, con un calo intraday di oltre il 20%. Ieri, il progetto ENA ha trasferito oltre 35 milioni di ENA alle principali borse centralizzate, con chiari segni di spedizione. Il ripristino del calo di una valuta forte potrebbe indicare che il trend al ribasso è entrato nella seconda fase e un ulteriore calo potrebbe essere un momento più adatto per prendere un minimo. Gli investitori dovrebbero monitorare attentamente le tendenze di mercato e prendere decisioni caute.</p>
<p>Nel complesso, il mercato sta vivendo deboli fluttuazioni e gli investitori devono essere cauti nel rispondere e nell’adattare le proprie strategie di investimento in base alle tendenze e alle dinamiche di mercato.</p>
<h2 id="h2-Macro20Wall20Street20ha20chiuso20in20ribasso20i20mercati20asiatici20hanno20registrato20alti20e20bassi20misti20e20leconomia20globale20potrebbe20sperimentare20una20crescita20lenta20e20stabile20questanno650769"><a name="Macro: Wall Street ha chiuso in ribasso, i mercati asiatici hanno registrato alti e bassi misti e l’economia globale potrebbe sperimentare una crescita ‘lenta e stabile’ quest’anno" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Wall Street ha chiuso in ribasso, i mercati asiatici hanno registrato alti e bassi misti e l’economia globale potrebbe sperimentare una crescita ‘lenta e stabile’ quest’anno</h2><p>Il Fondo Monetario Internazionale ha annunciato martedì che l’economia globale entrerà in un altro anno di “crescita lenta ma stabile”, poiché la forza degli Stati Uniti guiderà l’output mondiale per superare fattori sfavorevoli come l’inflazione sostenuta, la debole domanda dalla Cina e dall’Europa, e gli effetti di contagio di due guerre regionali.</p>
<p>Martedì, mentre il rendimento dei bond del tesoro statunitense aumentava, le azioni di Wall Street hanno chiuso al ribasso in una negoziazione altalenante. Gli investitori mostrano un atteggiamento cauto nel valutare l’elasticità dell’economia statunitense e l’impatto potenziale dell’inflazione persistente sulle tendenze dei tassi di interesse.</p>
<p>Il presidente della Federal Reserve, Jerome Powell, ha dichiarato che i recenti dati sull’inflazione non hanno dato abbastanza fiducia ai responsabili politici per facilitare rapidamente il credito. Ha sottolineato che la Federal Reserve potrebbe aver bisogno di mantenere i tassi di interesse a livelli più alti più a lungo del previsto.</p>
<p>Le prestazioni dei tre principali indici, l’indice Dow Jones è salito dello 0,17%, l’indice Standard &amp; Poor’s è sceso dello 0,21% e l’indice Nasdaq è sceso dello 0,12%. Il Dow è stato sostenuto dalle prestazioni migliori del previsto di United Health Group. Le azioni immobiliari e delle utility hanno trascinato l’indice S&amp;P 500, mentre le azioni tecnologiche hanno fornito la forza trainante maggiore per l’indice.</p>
<p>Il mercato ha ridotto significativamente il previsto taglio dei tassi di interesse di quest’anno a meno di due volte, un cambiamento significativo rispetto alle aspettative dell’inizio dell’anno. Nonostante una diminuzione della fiducia di mercato, si prevede comunque che il primo taglio dei tassi avrà luogo a settembre.</p>
<p>Mercoledì, i rendimenti dei titoli di stato USA hanno raggiunto un massimo di cinque mesi, il dollaro USA è schizzato contro le altre valute e i mercati azionari asiatici sono stati misti. L’indice azionario MSCI Asia Pacific al di fuori del Giappone è salito dello 0,2% dopo essere crollato di oltre il 4% negli ultimi tre giorni di contrattazioni. Le performance delle azioni di Taiwan sono state migliori rispetto al mercato generale, con un aumento del 1%, mentre le performance degli altri mercati sono state poco brillanti.</p>
<p>L’indice Nikkei in Giappone è sceso dello 0,7% al suo livello più basso in due mesi. Le azioni blue-chip cinesi sono scese dello 0,1%, mentre l’indice Hang Seng di Hong Kong è salito leggermente dello 0,1%.</p>
<p>Finora questa settimana, le questioni geopolitiche sono rimaste tese, ma i prezzi del petrolio si sono ammorbiditi poiché il vento contrario economico ha messo sotto pressione il sentiment degli investitori, soffocando i benefici delle tensioni geopolitiche. Il mercato è preoccupato da come Israele potrebbe rispondere all’attacco del weekend da parte dell’Iran al territorio israeliano.</p>
<p>I future del petrolio greggio Brent per la consegna di giugno sono scesi di 7 centesimi, o dello 0,1%, a $89,16 al barile, mentre i future del petrolio greggio statunitense per la consegna di maggio sono scesi di 10 centesimi, o dello 0,1%, a $85,26 al barile.</p>
<p>I prezzi del petrolio sono scesi presto mercoledì a causa dell’inerzia economica in Cina e delle preoccupazioni per la domanda globale indebolita dai recenti tagli dei tassi di interesse negli Stati Uniti, che hanno superato le preoccupazioni per l’offerta causate dall’escalation delle tensioni in Medio Oriente.</p>
<p>Il prezzo dell’oro rimane a $2,384.29 per oncia, non lontano dal massimo storico di $2,431.29.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Icing</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. Sarà consentito ripubblicare l'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div></div>