Tm90aXppZSBxdW90aWRpYW5lIHwgQlRDIGVkIEVUSCBzb25vIHNjZXNpLCBpbCBtZXJjYXRvIGRlbGxlIGNyaXB0b3ZhbHV0ZSBoYSBzdWJpdG8gdW4gcml0cmFjY2lhbWVudG87IFRldGhlciBoYSBsYW5jaWF0byB1biBudW92byB0b2tlbiBzdXBwb3J0YXRvIGRhbGwnb3JvOyBMYSBjYXBpdGFsaXp6YXppb25lIGRpIG1lcmNhdG8gaW5

2024-06-18, 03:36

<p><img src="https://gimg2.gateimg.com/image/article/17186816491_13.png" alt=""></p>
<h2 id="h2-Crypto20Daily20Digest20Tether20ha20lanciato20nuovi20token20supportati20da20oro20La20nuova20legge20sudcoreana20richiede20agli20exchange20di20rivedere20regolarmente20le20liste20di20token20Il20market20cap20iniziale20dellairdrop20di20ZKsync20si20avvicina20a2080020milioni20di20dollari513110"><a name="Crypto Daily Digest: Tether ha lanciato nuovi token supportati da oro; La nuova legge sudcoreana richiede agli exchange di rivedere regolarmente le liste di token; Il market cap iniziale dell’airdrop di ZKsync si avvicina a 800 milioni di dollari" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Daily Digest: <a href="/price/tether-usdt" target="_blank" class="blog_inner_link">Tether</a> ha lanciato nuovi token supportati da oro; La nuova legge sudcoreana richiede agli exchange di rivedere regolarmente le liste di token; Il market cap iniziale dell’airdrop di ZKsync si avvicina a 800 milioni di dollari</h2><p>Prima di tutto, esaminiamo le 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 17 giugno gli ETF Grayscale <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> spot (GBTC) hanno avuto un deflusso di fondi di $3 milioni. Nel frattempo, gli ETF Fidelity Bitcoin spot (FBTC) hanno registrato deflusso di $9200, gli ETF Bitwise Bitcoin spot (BITB) hanno registrato afflusso di $2.9 milioni e gli ETF ARK 21Shares Bitcoin spot (ARKB) hanno registrato deflusso di $50 milioni.</p>
<p><strong><a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> ha lanciato un nuovo token supportato dall’oro di custodia svizzero, ampliando la sintesi delle criptovalute</strong><br>Tether, il più grande fornitore di stablecoin per il dollaro statunitense, ha annunciato il lancio di una nuova criptovaluta chiamata ‘pegged assets’. Secondo una dichiarazione rilasciata lunedì, l’azienda lancerà un nuovo token supportato da oro fisico reale conservato in Svizzera per avviare una serie di rilasci di asset digitali.</p>
<p>Il primo prossimo token si chiama “Alloy by Tether”, abbreviato come aUSDT. Il CEO di Tether, Paolo Ardoino, ha dichiarato sulla piattaforma X: “Alloy di Tether è una piattaforma aperta che consente agli utenti di creare asset digitali garantiti e presto farà parte della nuova piattaforma di tokenizzazione degli asset digitali di Tether, che si prevede sarà lanciata entro la fine dell’anno.”</p>
<p>Tether descrive un USDT come una criptovaluta “progettata per tracciare il valore di un dollaro” ma “sovra-collateralizzata da <a href="/price/tether-gold-xaut" rel="nofollow noopener noreferrer" target="_blank">Tether Gold</a> (XAUT),” sottolineando che il token è supportato da oro reale. Gli utenti possono utilizzare XAUT come collaterale per creare token USDT. Attualmente, la capitalizzazione di mercato di XAUT è di $573 milioni, molto inferiore a quella di USDT.</p>
<p><strong>La nuova legge sudcoreana richiede agli scambi di rivedere regolarmente le quotazioni dei token</strong><br>La Corea del Sud implementerà la legge sulla protezione degli utenti di asset virtuali il 19 luglio. La Financial Services Commission (FSC) della Corea ha notificato 29 cripto scambi registrati per valutare regolarmente i token quotati sulle loro piattaforme e decidere se continuare a supportarne il trading.</p>
<p>La nuova legge richiede agli scambi di criptovalute di conformarsi a criteri più rigorosi per la revisione dell’elenco dei token e di rivedere i token già elencati ogni sei mesi per garantire che rispettino le nuove linee guida. Dopo la revisione iniziale, lo scambio deve condurre revisioni periodiche ogni tre mesi.</p>
<p>A febbraio di quest’anno, il governo sudcoreano ha rilasciato l’ultima versione rivista del Virtual Asset User Protection Act. A aprile, la Financial Supervisory Commission della Corea del Sud ha suggerito che avrebbe stabilito linee guida regolamentari più rigorose per l’elenco di nuovi token su cripto scambi, suggerendo misure per migliorare il monitoraggio del mercato e la sicurezza, come il divieto di elencare token per progetti infetti. Questi nuovi standard possono impedire che i token dei progetti con vulnerabilità di sicurezza e problemi di sicurezza irrisolti vengano elencati su scambi locali.</p>
<p><strong> La capitalizzazione di mercato iniziale della distribuzione gratuita di ZKsync è vicina a 800 milioni di dollari </strong><br>Il blockchain di livello 2 ZKsync ha lanciato una distribuzione altamente attesa del token ZK, con il 45% dei token che, secondo quanto riferito, sono stati richiesti in soli due ore. Secondo i dati di CoinGecko, il prezzo di apertura dei token ZK era di $0.31, seguito da una diminuzione di circa il 31%, e attualmente si attesta a $0.198. Secondo la fornitura in circolazione, la capitalizzazione di mercato è di circa 800 milioni di dollari, con circa 3.7 miliardi di token disponibili per la distribuzione. Calcolato dopo la diluizione completa, il valore di mercato è di 4.5 miliardi di dollari.</p>
<p>Alcuni utenti non sono soddisfatti del design dell’airdrop, ritenendo che ci sia un problema di distribuzione ingiusta e che alcuni presunti indirizzi stregoni stiano ricevendo una grande quantità di token. Il team riconosce il suo design non tradizionale. La settimana scorsa, il team di Matter Labs ha condiviso il piano di distribuzione dei token dell’associazione ZKsync.</p>
<p>Secondo il piano, l’89% degli airdrop sarà richiesto dagli utenti di ZKsync, inclusi tutti coloro che commerciano sulla blockchain di ZKsync e raggiungono una soglia di attività non specificata. I token restanti saranno allocati ai contributori dell’ecosistema, ai progetti nativi di ZKsync, alle comunità on-chain e ai costruttori.</p>
<p>Matter Labs ha anche dichiarato che i dipendenti riceveranno il 16,1% dei token ZK, mentre gli investitori riceveranno il 17,2%, che verranno bloccati per un anno e rilasciati entro tre anni. La restante fornitura di token sarà allocata alla conferenza dei token di ZKsync (29,3%) per nuovi scopi di governance, mentre la parte rimanente sarà utilizzata per la pianificazione dell’ecosistema (19,9%).</p>
<h2 id="h2-Tendenze20di20mercato792459"><a name="Tendenze di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tendenze di mercato</h2><p>BTC è salito oltre i $66.000 durante la notte e poi si è invertito, scendendo sotto i $65.000 questa mattina.</p>
<p>Il prezzo di ETH è sceso sotto i $3.400 questa mattina, indicando un certo declino.</p>
<p>Le altcoin sono generalmente diminuite di più del 10%, mentre il token di tendenza ZK con una grande capitalizzazione di mercato ha assorbito denaro caldo dal mercato.</p>
<h3 id="h3-Macroeconomia317815"><a name="Macroeconomia" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macroeconomia</h3><p>Tendenza di mercato: le azioni statunitensi continuano a salire a nuovi massimi storici, con i fondi che affluiscono verso le azioni tecnologiche.</p>
<h3 id="h3-Punti20Caldi20del20Mercato597785"><a name="Punti Caldi del Mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Punti Caldi del Mercato</h3><p>Protocollo Layer2 Zksync: ZK è stato lanciato ieri pomeriggio sulle principali piattaforme di trading, con un prezzo attuale di 0.2u, significativamente inferiore al prezzo fuori mercato di 0.4u. La capitalizzazione di mercato circolante attuale di ZK è di 740 milioni di dollari. La <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> la tassa del gas è scesa al minimo storico di 1 gas in 8 anni, e quando la tassa del gas per Layer1 non aumenta più, il racconto dell’industria per Layer2 non viene più accettato dal mercato.</p>
<p>Settore dei meme: MEW è salito del 25% durante il giorno ed è ora caduto. MEW è un token Meme di tipo gatto su <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Chain, che è stata recentemente lanciata sulla piattaforma di trading coreana e contratti su BN, con notizie positive continue. La capitalizzazione di mercato corrente di MEW è di quasi $400 milioni, rendendolo il meme token basato su gatti con la capitalizzazione di mercato più alta.</p>
<p>Il mercato delle criptovalute sta subendo una ondata di adeguamento rispetto alla tendenza attuale del mercato. Il ritiro di BTC e ETH indica una debolezza di mercato, e il diffuso declino delle Altcoin aggrava questa tendenza.</p>
<p>In termini di macroeconomia, l’ascesa costante e le prestazioni record delle azioni statunitensi potrebbero influenzare il <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Flusso</a> del denaro nel mercato delle criptovalute. Gli investitori potrebbero trasferire parte dei fondi dal mercato delle criptovalute al mercato azionario per cercare rendimenti più stabili.</p>
<h2 id="h2-Macro20Prima20della20pubblicazione20dei20commenti20della20Fed20lSampP2050020e20il20Nasdaq20hanno20toccato20nuovi20massimi20di20chiusura20mentre20Wall20Street20e20i20mercati20eurasiatici20sono20entrambi20saliti821459"><a name="Macro: Prima della pubblicazione dei commenti della Fed, l’S&amp;P 500 e il Nasdaq hanno toccato nuovi massimi di chiusura, mentre Wall Street e i mercati eurasiatici sono entrambi saliti" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Macro: Prima della pubblicazione dei commenti della Fed, l’S&amp;P 500 e il Nasdaq hanno toccato nuovi massimi di chiusura, mentre Wall Street e i mercati eurasiatici sono entrambi saliti</h2><p>Il 17 giugno, prima di pubblicare importanti dati economici e discorsi degli ufficiali della Federal Reserve di questa settimana, gli indici S&amp;P 500 e Nasdaq hanno registrato nuovi massimi di chiusura lunedì. L’entusiasmo per l’intelligenza artificiale ha principalmente guidato la crescita delle azioni tecnologiche. Tra le grandi azioni tecnologiche, Apple e Microsoft si sono riprese dopo il calo nella sessione di trading iniziale, chiudendo rispettivamente al rialzo del 1,97% e dell’1,31%. Dopo aver annunciato nuove funzionalità di intelligenza artificiale, la domanda di iPhone di Apple è stata riaccesa, proseguendo il trend al rialzo della scorsa settimana.</p>
<p>Indici specifici: l’indice Dow Jones è aumentato dello 0,49%, l’indice S&amp;P 500 è aumentato dello 0,77% e l’indice Nasdaq è aumentato dello 0,95%.</p>
<p>Due società di investimento hanno alzato le loro previsioni per l’S&amp;P 500 in base alla loro forza tecnologica e all’entusiasmo per l’intelligenza artificiale. Goldman Sachs ha aumentato il suo obiettivo per l’indice S&amp;P 500 alla fine del 2024 a 5.600 punti, mentre Evercore ISI ha aumentato la sua previsione per l’indice di riferimento da 4.750 punti a 6.000 punti.</p>
<p>I dati economici importanti che saranno resi pubblici questa settimana includono i dati sulle vendite al dettaglio di maggio martedì, seguiti dai dati sulla produzione industriale, i nuovi inizi di costruzione e il valore iniziale dell’indice dei responsabili degli acquisti S&amp;P. Inoltre, il mercato sarà chiuso per la festa di giugno mercoledì.</p>
<p>Il 18 giugno, i mercati azionari asiatici hanno seguito la crescita di Wall Street in attesa dei discorsi dei funzionari della Federal Reserve in giornata. Le preoccupazioni per le turbolenze politiche europee si sono attenuate, aumentando il sentimento del mercato e spingendo i futures dell’Eurostoxx 50 in rialzo dello 0,6%, invertendo parte del forte calo della scorsa settimana. Anche i futures dell’indice FTSE nel Regno Unito sono saliti dello 0,43%. Inoltre, la Banca d’Australia sta per annunciare la sua decisione sui tassi di interesse, spingendo la forza del dollaro australiano e dei mercati azionari interni.</p>
<p>L’indice azionario MSCI Asia Pacific è salito dello 0,68%, l’indice Nikkei in Giappone è salito dello 0,83%, l’indice Hang Seng ad Hong Kong è salito dello 0,14% e le blue chip cinesi sono salite leggermente dello 0,17%.</p>
<p>Il dollaro statunitense è leggermente sceso dello 0,04% rispetto allo yen giapponese a 157,68 yen nel mercato valutario. L’euro è sceso a $1,0729, mentre la sterlina è aumentata dello 0,04% a $1,27105. Il tasso di cambio onshore dello yuan cinese rispetto al dollaro statunitense è sceso a un minimo di sette mesi di 7,2554, in parte a causa dei dati economici misti pubblicati lunedì.</p>
<p>Per quanto riguarda le materie prime, i futures sul petrolio Brent sono saliti dello 0,11% a 84,34 dollari al barile. A causa delle prospettive di domanda in aumento e degli investitori che credono che i paesi produttori di petrolio dell’OPEC+ possano sospendere o ritirare i loro piani di produzione dal quarto trimestre di quest’anno, i prezzi del petrolio sono leggermente aumentati.</p>
<p>L’oro spot è salito dello 0,13% a $2.321,99 per oncia.</p>
<div class="blog-details-info"><br><div>Autore:<strong>Sherry S. &amp; Glassa</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 della violazione del copyright.<br></div><p></p><br></div></div></div></div>