Tm90aXppZSBxdW90aWRpYW5lIHwgQ3JpcHRvdmFsdXRlIGUgbWVyY2F0aSBnbG9iYWxpIGNyb2xsYW5vIGluc2llbWU7IElvVGVYIGZpbmFuemlhICQ1ME07ICQyNE0gZGkgc3RTT0wgbm9uIHBvc3Nvbm8gZXNzZXJlIHByZWxldmF0aSBhIGNhdXNhIGRlbCBidWcgZGkgc3Rha2luZyBkaSBMaWRvOyBPcGVuU2VhIHN1cHBvcnRhIGxvIHN

2024-04-03, 03:57

<p><img src="https://gimg2.gateimg.com/image/article/17121166243.png" alt=""></p>
<h2 id="h2-Riepilogo20giornaliero20delle20criptovalute20finanziamento20di205020milioni20per20la20blockchain20IoTeX20DePIN202420milioni20di20stSOL20non20possono20essere20prelevati20a20causa20di20un20bug20nello20staking20di20Lido20OpenSea20supporta20lo20standard20ERC721C732077"><a name="Riepilogo giornaliero delle criptovalute: finanziamento di $50 milioni per la blockchain IoTeX DePIN; $24 milioni di stSOL non possono essere prelevati a causa di un bug nello staking di Lido; OpenSea supporta lo standard ERC-721C" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riepilogo giornaliero delle criptovalute: finanziamento di $50 milioni per la blockchain <a href="/price/iotex-iotx" target="_blank" class="blog_inner_link">IoTeX</a> DePIN; $24 milioni di stSOL non possono essere prelevati a causa di un bug nello staking di Lido; OpenSea supporta lo standard ERC-721C</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. Secondo i dati di Farside Investor, il 2 aprile i fondi ETF spot di Grayscale (GBTC) hanno continuato a <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> in calo significativo, raggiungendo i 110,2 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 4,3 milioni di dollari e l’uscita di ARK 21Shares Bitcoin spot ETF (ARKB) è stata di 87,5 milioni di dollari.</p>
<p>Il 2 aprile, <a href="/price/iotex-iotx" rel="nofollow noopener noreferrer" target="_blank">IoTeX</a>, un <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>-blockchain compatibile ottimizzato per DePIN, ha annunciato informazioni sul finanziamento. Il progetto ha ricevuto investimenti per un totale di $50 milioni da Borderless Capital, Amber Group, Foresight Ventures, FutureMoney Group, SNZ, Metrics Ventures, EV3 e Waterdrop Capital.</p>
<p>Il team ha dichiarato che questo investimento mira a soddisfare la crescente domanda di collegare dati del mondo reale e dispositivi IoT a Web3. Hanno anche sottolineato che questo investimento favorirà la crescita e l’adozione degli ecosistemi DePIN investendo in $IOTX (token DePIN che gestiscono e guidano IoTeX DePIN) a lungo termine e collaborerà con la Fondazione IoTeX e il Fondo di Accelerazione DePINsurf per investire in progetti DePIN basati su IoTeX.</p>
<p>Il protocollo di staking SOL di Lido, del valore di 24 milioni di dollari, è inaccessibile agli utenti a causa di vulnerabilità nel codice; Attualmente, oltre 31.000 portafogli che detengono stSOL sono in difficoltà.</p>
<p>Lido ha annunciato nell’ottobre 2023 che smetterà gradualmente di fornire supporto per <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> e rimuova il sito web dove i detentori di stSOL scambiano i loro token per SOL. Quando Lido ha eliminato la pagina web a febbraio, gli utenti avevano ancora oltre 112.000 stSOL con un valore di mercato superiore ai 24 milioni di dollari.</p>
<p>Inoltre, secondo le notizie di ottobre dello scorso anno, Lido ha annunciato che non supporterà più il SOL staking e non supporterà più il nuovo SOL staking a partire dal 16 ottobre. Gli operatori dei nodi inizieranno a ritirarsi il 17 novembre. A partire dal 4 febbraio 2024, Lido, supportato dall’interfaccia utente di Solana, verrà terminato e l’annullamento del staking sarà possibile solo tramite l’interfaccia a riga di comando (CLI). Lido ha dichiarato che i detentori di stSOL possono comunque ricevere ricompense per il periodo di staking.</p>
<p>Lido non ha ancora risposto a questo.</p>
<p>La piattaforma di trading NFT OpenSea ha aggiunto il supporto per lo standard ERC-721C, che consente ai creatori di ottenere vantaggi programmabili ed eseguibili sulla catena.</p>
<p>ERC-721C è stato inventato dalla società di giochi blockchain Limit Break nel maggio dello scorso anno. Risolve il problema della mescolanza nelle transazioni NFT standardizzando le condizioni di trasferimento dei token (come le royalty) su tutti i canali. Prima della loro invenzione, gli utenti potevano trasferire NFT tramite portafogli auto-custoditi o altri mercati NFT che non rispettavano i requisiti di royalty del creatore, eludendo efficientemente le commissioni di royalty del creatore nel mercato secondario.</p>
<p>Secondo gli sviluppatori di OpenSea, la compatibilità con l’ERC-721C è stata abilitata solo nell’aggiornamento Dencun della rete <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> il 13 marzo. La piattaforma afferma: “Se segui i passaggi sopra per eseguire i tuoi guadagni da creatore, le vendite saranno supportate solo su OpenSea e altri mercati gestiti dai processori di pagamento di LimitBreak”. Dopo aver implementato il contratto ERC-721C su OpenSea, i creatori possono inserire manualmente le loro opere digitali in altri mercati. Tuttavia, OpenSea farà corrispondere anche le royalty minime impostate dai creatori su diverse piattaforme.</p>
<p><a href="/how-to-buy/cusdt-cusdt" rel="nofollow noopener noreferrer" target="_blank">dove acquistare cusdt</a><br>Questa mattina, BTC è brevemente sceso al di sotto di $64.500 e attualmente il prezzo è risalito a circa $66.000. Tuttavia, la media giornaliera è stata superata. Nel contesto del declino di BTC, l’intero mercato ha generalmente subito un forte calo. Inoltre, gli ETF spot di BTC hanno nuovamente mostrato uno stato di deflusso netto. Si sospetta che il mercato sia influenzato dalla vendita da parte del governo degli Stati Uniti di quasi $2 miliardi di Bitcoin precedentemente confiscati.</p>
<p>Sul fronte macroeconomico, il mercato azionario statunitense ha registrato una significativa diminuzione a causa della prevista riduzione dei tagli dei tassi di interesse, mentre l’indice del dollaro statunitense ha raggiunto un nuovo massimo in quattro mesi. Il rendimento del bond del tesoro decennale ha raggiunto il 4,2%.</p>
<h3 id="h3-Punti20Caldi20del20Mercato735966"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>ENA ha registrato un’impennata: dopo il lancio su Gate.io ieri, ENA è aumentata del 80% ed è ora quotata a $0,83, con il valore totale che raggiunge i $12 miliardi. USDe può connettersi a Pendle Finance sulla catena di Mantle tramite il ponte cross-chain Stargate per il mining, il che permette di risparmiare sui costi del gas rispetto alle operazioni sulla catena principale di Ethereum.</p>
<p>Settore RWA: nonostante la generale contrazione del mercato, i prezzi dei token come POLYX e PENDLE rimangono elevati.</p>
<p>Gate.io lancerà il token Wormhole W oggi alle 12:00 (UTC), che si prevede diventerà un importante punto caldo nel mercato.</p>
<p>Nel complesso, il sentiment di mercato tende ad essere pessimista e gli investitori devono rispondere con cautela. Tenete d’occhio il trend in crescita dei token del settore ENA e RWA e il prossimo lancio del token W di Wormhole su Gate.io. Nel frattempo, monitorate attentamente i rischi di mercato e adottate strategie d’investimento caute.</p>
<h2 id="h2-Macro20Declino20globale20dei20mercati20azionari20una20tempesta20potrebbe20colpire20Aumento20dei20prezzi20del20petrolio20greggio20e20delloro761682"><a name="Macro: Declino globale dei mercati azionari, una tempesta potrebbe colpire; Aumento dei prezzi del petrolio greggio e dell’oro" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Declino globale dei mercati azionari, una tempesta potrebbe colpire; Aumento dei prezzi del petrolio greggio e dell’oro</h2><p>Martedì, il mercato azionario statunitense è sceso mentre gli investitori valutavano la possibilità che la Federal Reserve rimandasse i tagli ai tassi di interesse. Allo stesso tempo, il produttore di veicoli elettrici Tesla ha annunciato il suo primo calo trimestrale delle consegne in quasi quattro anni, portando a una diminuzione dei prezzi delle azioni. Gli indicatori principali sono i seguenti: l’indice Dow Jones è sceso dell’1,00%, l’indice S&amp;P 500 è sceso dello 0,72% e l’indice Nasdaq è sceso dello 0,95%.</p>
<p>I rendimenti dei bond del Tesoro USA a 10 anni hanno raggiunto il 4,40%, il livello più alto di quest’anno. Tesla ha annunciato che il volume di consegne trimestrali è diminuito per la prima volta in quasi quattro anni, con il prezzo delle sue azioni in calo del 5%. Il mercato sta ancora considerando il rischio di rallentamento dei tagli dei tassi di interesse prima della pubblicazione dei dati statunitensi e prima dell’apparizione del governatore della banca centrale più tardi nella giornata. I prezzi del petrolio continuano a salire e i prezzi dell’oro hanno nuovamente raggiunto un nuovo record storico.</p>
<p>I mercati azionari asiatici sono scesi insieme a Wall Street mercoledì, principalmente perché il rendimento dei titoli di stato del tesoro statunitense è rimasto vicino a un massimo di quattro mesi, e il forte terremoto nella regione ha sollevato preoccupazioni per possibili interferenze nelle importanti industrie manifatturiere di chip. L’indice azionario MSCI Asia Pacific, il più ampiamente utilizzato al di fuori del Giappone, è sceso dello 0,7%. Dopo un significativo aumento del 20% nel primo trimestre, l’indice Nikkei in Giappone è sceso dell’1% mercoledì.</p>
<p>L’aumento dei rendimenti obbligazionari, il panico tra le società di Wall Street e la continua pressione sui prezzi sembrano rendere ancora più cupo l’outlook di mercoledì per il mercato asiatico. Gli investitori si stanno interrogando se questo segni l’inizio di una correzione più profonda.</p>
<p>Alcuni importanti rilasci sull’Agenda economica asiatica si baseranno principalmente sui dati dell’indice PMI del settore dei servizi di Cina e Giappone, ma il tono del mercato mercoledì potrebbe essere influenzato dall’ultima stretta delle condizioni finanziarie globali.</p>
<p>Nel frattempo, un sondaggio aziendale ha mostrato che l’attività del settore dei servizi in Giappone si è espansa al suo ritmo più rapido in sette mesi a marzo, sostenuta da una forte domanda, soprattutto per il turismo in entrata. Il settore dei servizi è sempre stato una forza trainante per la recente crescita economica del Giappone, contribuendo a compensare il calo della debole domanda globale sull’industria manifatturiera.</p>
<p>Secondo i dati rilasciati dall’indice, l’indice PMI dei servizi di AU Jibun Bank Services è salito da 52,9 a febbraio a 54,1 a marzo, segnando il 19° mese consecutivo di aumento.</p>
<p>Per quanto riguarda le materie prime sfuse, i prezzi del petrolio sono aumentati per il quarto giorno. L’escalation delle tensioni geopolitiche ha suscitato preoccupazioni per la stretta di offerta prima dell’incontro dell’OPEC+. È improbabile che l’organizzazione cambi la sua politica di produzione. Il petrolio greggio Brent è sceso dello 0,2% a $87,18 al barile, mentre il petrolio statunitense è sceso dello 0,3% a $83,21 al barile.</p>
<p>Mercoledì, i prezzi dell’oro hanno continuato la loro impennata record. L’oro spot ha raggiunto un massimo storico di $2.288,09 per oncia all’inizio della sessione di trading, seguito da alcuni incassi e alla fine è rimasto invariato a $2.277,99.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Icing</strong>, Ricercatore di Gate.io<br><div>Traduttore: Joy Z.<br><div class="info-tips"><em>Questo articolo rappresenta solo il punto di vista 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 ri-pubblicazione dell'articolo a condizione che Gate.io venga citato. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>