Tm90aXppZSBxdW90aWRpYW5lIHwgSSBzZXR0b3JpIE1lbWUgZSBBSSByaW1hbmdvbm8gZm9ydGk7IFRldGhlciBlbWV0dGVyw6AgdW4gdWx0ZXJpb3JlIDEgbWlsaWFyZG8gZGkgVVNEVDsgUnVuZXN0b25lIHNjYXZhIGlsIGJsb2NjbyBwacO5IGdyYW5kZSBuZWxsYSBzdG9yaWEgZGVsIEJUQw==

2024-03-04, 03:58
<p><img src="https://gimg2.gateimg.com/image/article/17095245811_2.png" alt=""></p>
<h2 id="h2-Riassunto20giornaliero20delle20criptovalute20Tether20emetter20ulteriori20120miliardo20di20USDT20Runestone20scava20il20blocco20pi20grande20nella20storia20di20Bitcoin20un20gran20numero20di20token20come20ARB20e20OP20verranno20sbloccati20a20marzo924227"><a name="Riassunto giornaliero delle criptovalute: Tether emetterà ulteriori 1 miliardo di USDT; Runestone scava il blocco più grande nella storia di Bitcoin; un gran numero di token, come ARB e OP, verranno sbloccati a marzo" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Riassunto giornaliero delle criptovalute: <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> emetterà ulteriori 1 miliardo di USDT; Runestone scava il blocco più grande nella storia di Bitcoin; un gran numero di token, come ARB e OP, verranno sbloccati a marzo</h2><p>Analizziamo le attività di trading di <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> ETF. Il 1 marzo i fondi GBTC di Grayscale hanno continuato a <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> uscito significativamente, raggiungendo 492 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 49,3 milioni di dollari, Bitwise Bitcoin spot ETF (BITB) è stato di 42,3 milioni di dollari e l’afflusso di ARK 21Shares Bitcoin spot ETF (ARKB) è stato di 55,1 milioni di dollari.</p>
<p>Secondo il monitoraggio di Whale , <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> ha emesso ulteriori 1 miliardo di USDT su <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> Il CEO di Tether, Paolo Ardoino, ha dichiarato che questi 1 miliardo di USDT integrano l’inventario della rete Ethereum. Si tratta di una transazione autorizzata ma non emessa, il che significa che questa emissione sarà utilizzata per la prossima richiesta di emissione e lo scambio cross-chain dell’inventario.</p>
<p>Lo sviluppatore di Ordinals, Leonidas, ha postato sulla piattaforma X, annunciando l’ultimo aggiornamento su Runestone: ‘Oggi Runestone ha scavato il blocco più grande nella storia di Bitcoin. Insieme, abbiamo creato la più grande iscrizione di Ordinals nella storia, con una dimensione di 3,97 MB. Senza il sostegno di diversi membri della comunità cinese di Ordinals che hanno donato per finanziarla. Non vedo l’ora di vedere quali risultati potremo raggiungere quando l’Oriente e l’Occidente collaboreranno di nuovo in futuro.’</p>
<p>Nel frattempo, hanno anche dichiarato che il prossimo passo nel processo di airdrop inizierà presto. Leonidas ha aggiunto: “Se partecipi al primo anno degli Ordinali, dovresti ottenere una Pietra Runica. E basta.”</p>
<p>Attualmente, il prezzo del pavimento in pietra runica è salito a $878, con un volume totale di transazioni di $610,000. Inoltre, Whales Market presto lancerà la sezione di trading delle Rune.</p>
<p>Secondo il monitoraggio dei dati di Token Unlocks, token come ARB, OP, SUI, MANTA, ecc. avranno sbloccaggi significativi a marzo, con un valore di oltre 3,4 miliardi di dollari.</p>
<p>I token rappresentativi includono il token ARB di Arbitrum, che sbloccherà 1,11 miliardi di token del valore di circa 2,15 miliardi di dollari alle 9:00 (UTC) del 16 marzo, corrispondenti all’87,2% dell’offerta circolante; SUI ha sbloccato 34,62 milioni di token del valore di circa 57,46 milioni di dollari alle 8:00 (UTC) del 3 marzo, corrispondenti al 2,81% dell’offerta circolante; Il token MANTA di Manta Network sbloccherà 6,67 milioni di token del valore di circa 17,47 milioni di dollari alle 17:30 (UTC) del 18 marzo, corrispondenti al 2,66% dell’offerta circolante; <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Ottimismo</a> Il token OP sbloccherà 24,16 milioni di token del valore di circa 88,18 milioni di dollari alle 12:00 (UTC) del 29 marzo, rappresentando il 2,4% dell’offerta circolante; il token SingularityNET AGIX sbloccherà 8,84 milioni di token del valore di circa 6,09 milioni di dollari il 28 marzo alle 8:00 (UTC), rappresentando lo 0,69% dell’offerta circolante.</p>
<h2 id="h2-Tendenze20di20mercato20le20zone20calde20di20Meme20e20AI20continuano20con20prestazioni20eccezionali20nei20progetti20POW20e20public20chain454402"><a name="Tendenze di mercato: le zone calde di Meme e AI continuano, con prestazioni eccezionali nei progetti POW e public chain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato: le zone calde di Meme e AI continuano, con prestazioni eccezionali nei progetti POW e public chain</h2><p>BTC ha sperimentato un breve calo nel pomeriggio di domenica, ma si è rapidamente ripreso e ha continuato a salire, mostrando una tendenza al rialzo molto forte. Il trading ad alto livello è stato per lo più liquidato durante il calo del fine settimana e la situazione di mercato è relativamente sana. Il mercato si concentra ripetutamente sui settori dell’IA e dei Meme. È interessante notare che il mercato spesso subisce un significativo ritracciamento entro 1-2 mesi dopo un significativo aumento dei Meme.</p>
<p>Dal punto di vista macroeconomico, le azioni statunitensi sono aumentate, con notizie che suggeriscono che il primo taglio dei tassi potrebbe avvenire a giugno di quest’anno.</p>
<h3 id="h3-Punti20caldi20del20mercato876693"><a name="Punti caldi del mercato:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti caldi del mercato:</h3><p>Il settore dei meme: questo settore ha registrato aumenti significativi delle criptovalute come PEPE, FLOKI, WIF, MOG e TRUMP. Tra queste, il prezzo di FLOKI è triplicato nel weekend dopo aver votato per distruggere il 2% delle monete in circolazione. WIF ha continuato a mostrare una forte performance dopo il lancio di Robinhood la scorsa settimana. WIF è stato il terzo token meme a lanciare Robinhood, dopo DOGE e SHIB. E le due valute sopra citate hanno ottenuto ottimi risultati nel precedente mercato rialzista.</p>
<p>Serie POW: Vecchie valute come BCH, BSV, SYS e SMH hanno registrato aumenti significativi. Con l’avvicinarsi dell’halving di BTC ad aprile, i minatori si stanno orientando verso il mining di altre token POW. La logica qui è simile alla situazione in cui la potenza di calcolo di ETC ha registrato un aumento significativo dopo che <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> ha adottato POS.</p>
<p>Progetti di blockchain pubblica: questa mattina, FTM, ONE, NEAR e altri progetti di blockchain pubblica hanno guidato l’aumento, dimostrando l’attenzione e il riconoscimento degli investitori verso questi progetti.</p>
<p>Complessivamente, il mercato del fine settimana è rimasto stabile, ma Meme e AI rimangono argomenti caldi nel mercato. Inoltre, il concetto di POW e i progetti di blockchain pubblici hanno mostrato anche una performance eccezionale. Gli investitori dovrebbero monitorare attentamente le tendenze di mercato, cogliere le opportunità di investimento, rimanere cauti e allocare in modo ragionevole le risorse. Gate.io continuerà a fornire agli utenti servizi completi per aiutarli a ottenere maggiori profitti nel campo degli asset digitali.</p>
<h2 id="h2-Macro20I20mercati20azionari20globali20mostrano20un20sentimento20positivo20e20i20mercati20asiatici20sono20pronti20per20la20crescita20i20paesi20membri20di20OPEC20riducono20la20produzione20di20petrolio20e20fanno20salire20i20prezzi20del20petrolio107727"><a name="Macro: I mercati azionari globali mostrano un sentimento positivo e i mercati asiatici sono pronti per la crescita; i paesi membri di OPEC+ riducono la produzione di petrolio e fanno salire i prezzi del petrolio" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: I mercati azionari globali mostrano un sentimento positivo e i mercati asiatici sono pronti per la crescita; i paesi membri di OPEC+ riducono la produzione di petrolio e fanno salire i prezzi del petrolio</h2><p>Per quanto riguarda i mercati azionari globali, Reuters ha riferito che il sentimento generale è alto; l’MSCI World, il Nikkei 225, il Nasdaq, il S&amp;P 500 e lo Stoxx 600 in Europa hanno raggiunto tutti livelli storici la scorsa settimana. La resilienza dell’economia statunitense, il rallentamento dell’inflazione e l’euforia delle grandi aziende tecnologiche guidate dall’intelligenza artificiale stanno creando un tono positivo per il mondo, che dovrebbe portare vitalità al mercato lunedì.</p>
<p>Il Congresso Nazionale del Popolo annuale si aprirà a Pechino martedì, e la sua formulazione potrebbe avere un impatto significativo nel determinare la direzione degli asset cinesi nel 2024. Se le politiche e le misure di stimolo sono credibili agli occhi degli investitori, è probabile che il rimbalzo del mercato azionario cinese da un minimo quinquennale di alcune settimane fa continui. Se non riescono a convincere gli investitori, potrebbero riprovare questi minimi nelle prossime settimane.</p>
<p>A causa delle scarse prestazioni dei dati, le aspettative sono diminuite significativamente nelle ultime settimane, quindi non è chiaro se ciò rifletta un’attività economica particolarmente forte. Ma il mercato azionario cinese merita comunque di essere guardato con interesse, essendo salito di circa il 10% dal suo punto più basso e mantenendosi in un trend positivo quest’anno.</p>
<p>Nel frattempo, secondo fonti informate, il governo giapponese prenderà una decisione dopo aver determinato se i negoziati annuali sul salario del lavoro, svoltisi il 13 marzo, saranno sufficienti a compensare gli aumenti dei prezzi e a valutare le prospettive delle tendenze dei prezzi. Le fonti dicono che, se attuato, ciò significherà che il Giappone si libererà dalla deflazione che ha trascinato l’attività economica per oltre 20 anni.</p>
<p>Altri importanti dati asiatici, principalmente dati sull’inflazione dalla Corea del Sud, dalla Thailandia, dalle Filippine e da Taiwan, nonché dati sul PIL dalla Corea del Sud e dall’Australia, PMI dei servizi di Caixin della Cina e decisioni sui tassi di interesse, provengono dalla Malaysia.</p>
<p>Per quanto riguarda le materie prime, i paesi membri dell’OPEC+, guidati da Arabia Saudita e Russia, hanno concordato domenica di estendere i tagli volontari alla produzione di 2,2 milioni di barili al giorno fino al secondo trimestre, fornendo ulteriore sostegno al mercato tra le preoccupazioni per la crescita economica globale e l’aumento della produzione. I tre paesi produttori di petrolio dell’OPEC hanno dichiarato nelle rispettive dichiarazioni che l’Iraq estenderà la riduzione della produzione giornaliera di 220.000 barili, gli Emirati Arabi Uniti manterranno la riduzione della produzione giornaliera di 163.000 barili e il Kuwait manterrà la riduzione della produzione giornaliera di 135.000 barili. L’Algeria ha anche dichiarato che ridurrà la produzione di 51.000 barili al giorno, mentre l’Oman ridurrà la produzione di 42.000 barili al giorno. Il Kazakistan ha dichiarato che estenderà il periodo di riduzione volontaria della produzione di 82.000 barili al giorno fino al secondo trimestre.</p>
<p>Arabia Saudita, il leader de facto dell’Organizzazione dei Paesi Esportatori di Petrolio (OPEC), ha annunciato che estenderà il periodo di riduzione volontaria della produzione di 1 milione di barili al giorno fino alla fine di giugno, mantenendo la sua produzione intorno ai 9 milioni di barili al giorno.</p>
<p>La Russia, che guida gli alleati dell’OPEC (collettivamente chiamati OPEC+), ridurrà la produzione e le esportazioni di petrolio di ulteriori 471.000 barili al giorno nel secondo trimestre. I nuovi dati forniti dal vice primo ministro russo Alexander Novak mostrano che la proporzione delle misure di riduzione della produzione continuerà ad aumentare in questa misura.</p>
<p>Sebbene le preoccupazioni sulla crescita economica abbiano esercitato una certa pressione sui prezzi del petrolio, ci si aspetta che le tensioni geopolitiche nel 2024 e gli attacchi delle forze armate Housai alle spedizioni nel Mar Rosso sostengano i prezzi del petrolio. Nonostante sia ampiamente previsto che OPEC+ continuerà a ridurre la produzione, l’annuncio della Russia potrebbe ulteriormente far salire i prezzi del petrolio.</p>
<p>Venerdì, i prezzi del petrolio greggio Brent sono saliti di $1,64, un aumento del 2%, a $83,55 al barile, e sono aumentati di oltre l’8% quest’anno. Domenica, i paesi membri dell’OPEC+ hanno annunciato i rispettivi piani di riduzione della produzione, seguiti da una dichiarazione che conferma una riduzione totale di 2,2 milioni di barili al giorno. L’agenzia di stampa nazionale saudita SPA ha dichiarato che la riduzione della produzione sarà gradualmente annullata in base alle condizioni di mercato.</p>
<p>“L’estensione è prevista, ma estenderla fino alla fine del secondo trimestre potrebbe essere sorprendente”, ha detto Tamas Walga del broker petrolifero PVM. Ha aggiunto: “Si prevede che il mercato aprirà più forte”.</p>
<p>Dal termine del 2022, OPEC+ ha attuato una serie di misure di riduzione della produzione per sostenere il mercato a causa dell’aumento della produzione negli Stati Uniti e in altri paesi produttori di petrolio non membri, nonché delle preoccupazioni delle principali economie per i tassi di interesse elevati. Secondo le stime di Reuters, la riduzione totale promessa nella produzione di OPEC+ dal 2022 è di circa 5,86 milioni di barili al giorno, equivalente a circa il 5,7% della domanda giornaliera globale.</p>
<p>Le prospettive per la domanda di petrolio quest’anno sono incerte. L’OPEC prevede una crescita della domanda relativamente forte, trainata dall’Asia, a 2,25 milioni di barili al giorno. Allo stesso tempo, l’Agenzia internazionale dell’energia prevede un significativo rallentamento della crescita della domanda, a 1,22 milioni di barili al giorno. L’IEA prevede anche che l’offerta di petrolio crescerà fino a raggiungere un massimo storico di circa 103,8 milioni di barili al giorno quest’anno. Questo rappresenta un’ulteriore resistenza per l’OPEC+, guidata quasi interamente dai paesi produttori non appartenenti all’OPEC+, tra cui gli Stati Uniti, il Brasile e la Guyana.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S.</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. La ripubblicazione dell'articolo sarà consentita 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>
Share
Content
gate logo
Gate
Trade Now
Join Gate to Win Rewards