Tm90aXppZSBxdW90aWRpYW5lIHwgTCdoYWx2aW5nIHN0YSBhcnJpdmFuZG8sIGdsaSBhbmFsaXN0aSBkaSBKUE1vcmdhbiBkaWNvbm8gY2hl4oCcIEJUQyBjYWRyw6Agc2ljdXJhbWVudGUgZG9wbyBsJ2hhbHZpbmcg4oCdOyBJbCBwcm90b2NvbGxvIGRpIGRpc3BvbmliaWxpdMOgIGRlaSBkYXRpIEF2YWlsIGhhIGFubnVuY2lhdG8gNjA

2024-04-19, 04:05

<p><img src="https://gimg2.gateimg.com/image/article/171349949219.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20gli20analisti20di20JPMorgan20dicono20che20Bitcoin20sicuramente20cadr20dopo20il20dimezzamento20il20protocollo20di20disponibilit20dei20dati20Avail20ha20annunciato2060020milioni20di20token20airdrop392173"><a name="Crypto Daily Digest: gli analisti di JPMorgan dicono che “Bitcoin sicuramente cadrà dopo il dimezzamento”; il protocollo di disponibilità dei dati Avail ha annunciato 600 milioni di token airdrop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: gli analisti di JPMorgan dicono che “Bitcoin sicuramente cadrà dopo il dimezzamento”; il protocollo di disponibilità dei dati Avail ha annunciato 600 milioni di token airdrop</h2><p>Prima, diamo un’occhiata a <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Attività di trading degli ETF. Secondo i dati di Farside Investor, il 18 aprile i fondi Grayscale GBTC sono usciti per un totale di 90 milioni di dollari. Nel frattempo, sono stati registrati afflussi di 37,4 milioni di dollari per il Fidelity <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> Spot ETF (FBTC), di 12,8 milioni di dollari per il Bitwise Bitcoin Spot ETF (BITB), di 9,5 milioni di dollari per l’ARK 21Shares Bitcoin Spot ETF (ARKB) e di 6,6 milioni di dollari di afflussi netti per il WisdomTree Bitcoin Spot ETF (BTCW).</p>
<p>Gli analisti di JPMorgan ritengono che i prezzi del Bitcoin cadranno dopo essere stati dimezzati e che il mercato abbia già riflettuto su questo evento. Il prezzo attuale del Bitcoin è di $61,942.3.</p>
<p>L’analista Nikolaos Panigrtzoglou ha evidenziato in un rapporto mercoledì che “non ci aspettiamo che i prezzi di Bitcoin aumentino dopo il dimezzamento, poiché il mercato ha già valutato questo evento.” Questa visione è simile alle loro opinioni precedenti. L’analista ha spiegato: “In effetti, crediamo che potrebbe esserci un trend al ribasso nei prezzi di Bitcoin dopo il dimezzamento per diverse ragioni.”</p>
<p>Una delle ragioni è che Bitcoin è ancora in uno stato di ipercomprato, come si può vedere dall’analisi dei contratti aperti nei futures di Bitcoin. Inoltre, hanno anche indicato che rispetto all’oro, il prezzo di Bitcoin è ancora molto più alto rispetto al prezzo regolato di JPMorgan di $45.000 e ancora più alto del costo di produzione previsto di $42.000 dopo l’halving.</p>
<p>Gli analisti hanno osservato che nonostante il recupero del mercato delle criptovalute, il capitale di rischio delle criptovalute è stato tiepido finora quest’anno, il che potrebbe anche causare un rallentamento del prezzo del Bitcoin dopo l’halving.</p>
<p>Nel frattempo, mentre i minatori di Bitcoin non redditizi escono dalla rete Bitcoin, ci si aspetta che la loro potenza di calcolo diminuisca significativamente e i minatori di Bitcoin quotati domineranno la quota di mercato. Dopo il dimezzamento, alcune società di mining di Bitcoin potrebbero considerare la diversificazione degli investimenti in regioni con costi energetici inferiori, come America Latina o Africa, per riutilizzare le loro attrezzature di mining inefficienti per ottenere un valore residuo.</p>
<p>“Unification Drop è una forza unificata che unisce diverse comunità, premiando sviluppatori, contributori alla governance, educatori tecnici, utenti di roll-up, sostenitori e altri contributori di valore dalle diverse comunità blockchain”, ha dichiarato Avail il 18 aprile.</p>
<p>Avail è uno strato di infrastruttura <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> costruito utilizzando <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> La suite di sviluppo software di Avail, che farà un airdrop di 600 milioni di token native AVAIL agli utenti. Avail è stata fondata nel 2020 e Avail DA ha ulteriormente migliorato le transazioni del livello di base espandendo l’aggregazione attraverso metodi come l’impegno KZG e il campionamento della disponibilità dei dati.</p>
<p>Avail viene utilizzato per ottenere i servizi Avail DA, proteggere il livello unificato attraverso lo staking e partecipare alla governance. I token vengono distribuiti tramite airdrop in base al tempo totale, alla profondità e all’impatto degli impegni degli utenti nell’ecosistema. Dopo il lancio del mainnet, 354.605 indirizzi del portafoglio riceveranno i token AVAIL tramite airdrop.</p>
<p>La disponibilità dei dati consente ai nodi di verificare le transazioni raggruppate senza scaricare tutti i dati dal blocco. Nel frattempo, l’impegno comune KZG nei protocolli a conoscenza zero consente di verificare i dati sottostanti senza divulgare informazioni personali. Nel frattempo, Avail Nexus fornisce agli utenti un ponte cross-chain per transazioni di asset o scambi tra più blockchain. Infine, Avail Fusion consente il locking di liquidità di <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, Bitcoin e altri asset.</p>
<h2 id="h2-Tendenze20di20mercato20BTC20dimezzamento20in20meno20di20un20giorno20con20debole20ripresa20di20mercato766031"><a name="Tendenze di mercato: BTC dimezzamento in meno di un giorno con debole ripresa di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: BTC dimezzamento in meno di un giorno con debole ripresa di mercato</h2><p>Il mercato complessivo delle criptovalute ha vissuto un debole rimbalzo, con Bitcoin che ha brevemente superato i $64.000 ma attualmente è tornato a circa $61.000. Gli ETF spot di Bitcoin hanno registrato deflussi netti per quattro giorni consecutivi. A meno di un giorno dal dimezzamento di Bitcoin, avverrà il 20 aprile. Riguardo alla macroeconomia, il mercato azionario statunitense ha sperimentato volatilità, con il Presidente della Federal Reserve, Bostek, che ha affermato che i livelli di inflazione sono troppo alti e ci si aspetta che i tassi di interesse non saranno abbassati prima della fine dell’anno.</p>
<h3 id="h3-Hotspot20di20mercato592329"><a name="Hotspot di mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hotspot di mercato:</h3><p>Token concettuali nazionali come ONG, ONT, <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a>, GAS e <a href="/price/qtum-qtum" target="_blank" class="blog_inner_link">QTUM</a> hanno mostrato un’impressionante performance nel rimbalzo di ieri. Questi progetti sono tutte valute concettuali nazionali che hanno vissuto molteplici cicli di rialzi e ribassi, ma vale la pena notare che il loro traino non è sostenibile.</p>
<p>La catena pubblica modulare Avail annuncia un airdrop: Avail annuncia un airdrop di token agli utenti della testnet, agli staker di MATIC e ad altri utenti attivi di Layer2. I concorrenti di Avail includono Celestia ed Eigenlayer, tra gli altri. Questa notizia potrebbe attirare più utenti a partecipare al progetto Avail e influenzare i prezzi dei suoi token.</p>
<p>In sintesi, le prestazioni complessive dei prezzi del mercato delle criptovalute sono deboli. Con l’avvicinarsi dell’halving di BTC in meno di un giorno, potrebbero verificarsi significative fluttuazioni di mercato prima e dopo l’halving. Gli investitori devono monitorare le tendenze di mercato e regolare prontamente le proprie strategie di investimento.</p>
<h2 id="h2-Macro20Continua20tensione20in20Medio20Oriente20dollaro20statunitense20in20aumento20e20costante20aumento20delloro20e20del20petrolio20greggio569022"><a name="Macro: Continua tensione in Medio Oriente, dollaro statunitense in aumento e costante aumento dell’oro e del petrolio greggio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Continua tensione in Medio Oriente, dollaro statunitense in aumento e costante aumento dell’oro e del petrolio greggio</h2><p>Il mercato azionario statunitense ha chiuso quasi invariato giovedì, poiché gli investitori hanno esaminato attentamente gli ultimi rapporti finanziari delle aziende. I dati economici e i commenti dei funzionari della Federal Reserve indicano che la Fed è improbabile che riduca i tassi di interesse nel prossimo futuro. I dati economici mostrano che il mercato del lavoro rimane resiliente, con il numero di richiedenti sussidi di disoccupazione per la prima volta alla settimana rimasto lo stesso della settimana precedente.</p>
<p>L’indice S&amp;P 500 è sceso per il quinto giorno consecutivo di negoziazione a causa delle recenti difficoltà nel mercato azionario dopo una crescita di cinque mesi iniziata a novembre, in parte a causa delle aspettative che la Federal Reserve possa ridurre i tassi di interesse nella prima metà di quest’anno.</p>
<p>Sul lato positivo, dopo che META e Bernstein hanno aumentato il loro prezzo obiettivo da $535 a $590, l’indice S&amp;P 500 è salito dell’1,54%, il maggior contributo all’indice S&amp;P 500.</p>
<p>Ci sono segnalazioni di un’acuta escalation delle ostilità in Medio Oriente, con azioni asiatiche e rendimenti obbligazionari in calo venerdì, mentre valute rifugio, oro e petrolio greggio sono aumentati.</p>
<p>Il mercato asiatico dovrebbe concludere una settimana lenta con un tono positivo venerdì, ma a causa delle tensioni in corso in Medio Oriente, del peggioramento del sentiment globale e della mancanza di volontà di assumere troppi rischi prima del fine settimana, potrebbe limitare il momentum al rialzo del mercato.</p>
<p>Le principali notizie dalla comunità finanziaria globale di Washington continuano a rendere i trader nervosi, soprattutto per quanto riguarda i tassi di cambio e le politiche delle banche centrali rispetto alla sempre più falconiana Federal Reserve. Il dollaro statunitense è rimasto forte, salendo del 3% nelle ultime settimane, raggiungendo il suo massimo da novembre.</p>
<p>I rendimenti dei titoli di Stato americani sono aumentati nuovamente e saliranno per la terza settimana consecutiva, con il rendimento dei titoli di Stato a due anni che sale al 5%. Nelle ultime settimane, il rendimento dei titoli di Stato a due e dieci anni è aumentato di 40-45 punti base.</p>
<p>I mercati azionari asiatici stanno affrontando il loro più grande calo settimanale da gennaio, con l’indice MSCI Asia (escluso il Giappone) che questa settimana è sceso del 2,3%, in ribasso del 5% rispetto al suo massimo della settimana scorsa. Si tratta del restringimento delle condizioni finanziarie con cui i mercati emergenti cercano di far fronte.</p>
<p>A causa delle preoccupazioni per i problemi di approvvigionamento in Medio Oriente, i futures del petrolio Brent sono saliti del 3% a 89,74 dollari al barile.</p>
<p>L’oro è salito dell’1,3% a $2.409,45, avvicinandosi gradualmente all’ultimo massimo storico della scorsa settimana di $2.431,29.</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 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 si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div></div>