TGEgQ2luYSBzdGEgcGVyIGxhbmNpYXJlIHVuIENlbnRybyBuYXppb25hbGUgcGVyIGxhIGJsb2NrY2hhaW46IFN2aWx1cHBvIGRlbGxhIHRlY25vbG9naWEgYmxvY2tjaGFpbiBpbiBDaW5h

2023-03-13, 14:29

<p><img src="https://gimg2.gateimg.com/image/article/1678717228加密货币指南 封面.jpeg" alt=""></p>
<h2 id="h2-TL20DR261641"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>La Cina sta lavorando per potenziare la sua tecnologia nazionale della blockchain al fine di supportare la sua economia in espansione.</p>
<p>Anche se la Cina ha vietato le criptovalute, mira a sviluppare la tecnologia blockchain cinese.</p>
<p>Il Ministero della Scienza e della Tecnologia ha approvato l’introduzione del Centro Nazionale per l’Innovazione della Tecnologia Blockchain.</p>
<p>Il presidente cinese, Xi Jinping, ritiene che il paese debba espandere la rete blockchain cinese se vuole rimanere competitivo nell’ambiente economico globale in evoluzione.</p>
<h2 id="h2-Introduzione61819"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La tecnologia blockchain continua a cambiare il modo in cui i paesi controllano le loro risorse e migliorano il benessere dei loro cittadini. Il vantaggio che i paesi hanno nel guadagnare vantaggi competitivi rispetto ai loro rivali è un’altra ragione per cui continuano a condurre ricerche e sviluppo su come sfruttare la tecnologia blockchain.</p>
<p>La Cina è uno dei paesi che hanno annunciato un nuovo focus strategico su come utilizzare la tecnologia blockchain. Recentemente, ha divulgato il suo obiettivo di lanciare il Centro di innovazione tecnologica nazionale della blockchain nella città capitale, Pechino.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/716/the-main-countries-that-actually-banned-crypto" target="_blank">I principali paesi che hanno effettivamente vietato le criptovalute</a></p>
<h2 id="h2-Piano20per20istituire20il20Centro20Nazionale20per20lInnovazione20Tecnologica20della20Blockchain596054"><a name="Piano per istituire il Centro Nazionale per l’Innovazione Tecnologica della Blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Piano per istituire il Centro Nazionale per l’Innovazione Tecnologica della Blockchain</h2><p>La Cina sta pianificando di istituire il Centro nazionale di innovazione tecnologica Blockchain, nonostante il suo attuale divieto sulle criptovalute. Questo è stato recentemente annunciato dal Ministero della Scienza e della Tecnologia della Cina.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1678717607CBDC1.png" alt=""><br>La Cina istituirà un Centro nazionale per l’innovazione tecnologica Blockchain- Alexablockchain</p>
<p>Lo scopo del centro è quello di svolgere ricerche sulla tecnologia blockchain per potenziare lo sviluppo industriale e l’economia nazionale. L’altro obiettivo è capire come applicare la blockchain ai vari settori economici.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1415/understanding-chinas-digital-yuan" target="_blank">Comprensione dello yuan digitale cinese</a></p>
<p>Il centro collaborerà con università, imprese e istituti di ricerca per sperimentare il blockchain e trovare modi innovativi di utilizzare la tecnologia per risolvere le sfide che il paese sta affrontando, nonché creare un vantaggio competitivo nell’ambiente globale in continua evoluzione.</p>
<p>Inoltre, il National Blockchain Technology Innovation Center si concentrerà sulla teoria fondamentale della blockchain e sui relativi sistemi software e hardware. Le scoperte e le innovazioni guidate dal centro espanderanno la rete blockchain cinese e miglioreranno la digitalizzazione dell’economia e della società cinese in generale.</p>
<p>È anche importante notare che il presidente della Repubblica popolare cinese, Xi Jinping, sostiene lo sviluppo della tecnologia blockchain perché crede che abbia il potere di trasformare la base industriale del paese. Il centro dovrebbe esplorare vari casi d’uso della tecnologia blockchain.</p>
<p>Poco dopo l’approvazione del presidente Xi Jinping della tecnologia blockchain, molte startup, aziende tecnologiche e altri investitori si sono uniti allo spazio blockchain nel paese. A luglio 2022, il paese ha segnalato che 1.821 aziende si erano registrate presso l’Amministrazione dello Spazio Cibernetico della Cina (CAC).</p>
<h2 id="h2-Ruolo20dellAccademia20di20Pechino20di20Blockchain20e20Edge20Computing20BABEC607115"><a name="Ruolo dell’Accademia di Pechino di Blockchain e Edge Computing (BABEC)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Ruolo dell’Accademia di Pechino di Blockchain e Edge Computing (BABEC)</h2><p>Come parte del National Blockchain Technology Innovation Center, l’Accademia di Blockchain e Edge Computing di Pechino (BABEC), supportata dal governo municipale di Pechino, svolgerà un ruolo di primo piano nello sviluppo della tecnologia blockchain nel paese.</p>
<p>Il motivo per cui l’Accademia di Pechino per la Blockchain e l’Edge Computing (BABEC) è stata incaricata di guidare il centro è dovuto alla sua esperienza nel settore della blockchain. BABEC è ben noto per lo sviluppo di Chang’an Chain o ChainMaker blockchain, supportata da molte imprese cinesi e dalle imprese statali strategiche come la China Construction Bank.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1678717632CBDC2.png" alt=""><br>China Construction Bank - Ledgerinsight</p>
<p>Già, la blockchain ChainMaker supporta molte aree chiave dell’economia cinese come i servizi fiscali del governo, la finanza della catena di approvvigionamento, i sistemi di identità digitale e altri servizi governativi.</p>
<p>Ad esempio, il governo di Pechino ha istituito la versione 2.0 della sua directory dei dati sulla blockchain di ChainMaker. Questa applicazione raccoglie e sintetizza i dati provenienti da 16 zone di sviluppo economico e più di 80 dipartimenti governativi situati a Pechino.</p>
<p>BABEC ha anche sviluppato e lanciato il cluster di computer HIVE sulla blockchain di ChainMaker. Questa rete è molto veloce poiché gestisce oltre 240 milioni di transazioni al secondo, il che migliora la sua capacità di elaborare grandi volumi di dati.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/1230/wechat-bans-accounts-involved-in-crypto-and-nft-as-china-tightens-up-on-crypto" target="_blank">WeChat vieta gli account coinvolti in criptovalute e NFT mentre la Cina si stringe sulla criptovaluta</a></p>
<h2 id="h2-Lo20stato20attuale20della20Cina20nella20tecnologia20blockchain546565"><a name="Lo stato attuale della Cina nella tecnologia blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Lo stato attuale della Cina nella tecnologia blockchain</h2><p>La pronuncia del governo per potenziare la tecnologia blockchain cinese non significa che il paese sia stato inattivo nel corso degli anni. Nonostante il divieto delle criptovalute nel paese, la tecnologia blockchain cinese si è sviluppata a un ritmo veloce.</p>
<p>Ad esempio, la Cina è uno dei paesi che ha fatto molto nello sviluppo della sua valuta digitale della banca centrale. In particolare, il paese ha già prodotto e distribuito il suo e-Yuan del valore di milioni di dollari statunitensi.</p>
<p>Inoltre, la Cina è in testa nel fornire servizi di mining di criptovalute in quanto dispone di fonti energetiche a basso costo e condizioni climatiche favorevoli. Attualmente, la Cina controlla oltre il 70% del totale. <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> hashrate.</p>
<p>È anche un importante produttore e fornitore di attrezzature per l’estrazione di criptovalute. Ad esempio, una delle sue grandi aziende, Bitmain, è tra i leader mondiali nella produzione di attrezzature per l’estrazione di criptovalute.<br>Ci sono anche molte aziende blockchain come Binance che hanno le loro radici in Cina. La ragione per cui tali aziende operano al di fuori del paese è dovuta al divieto imposto sulle criptovalute.</p>
<h2 id="h2-Conclusione392622"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>In breve, la Cina è disposta a promuovere la sua tecnologia blockchain per spingere la sua trasformazione industriale. Il fatto che il paese abbia vietato le criptovalute non implica che non apprezzi la tecnologia blockchain. In realtà, il presidente cinese, Xi Jinping, ritiene che la blockchain abbia un ruolo critico da svolgere nell’economia.</p>
<h2 id="h2-Domande20frequenti20sulla20Blockchain20in20Cina516342"><a name="Domande frequenti sulla Blockchain in Cina" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Domande frequenti sulla Blockchain in Cina</h2><p><strong>È disponibile la blockchain in Cina?</strong></p>
<p>La Cina utilizza la tecnologia blockchain in vari settori della sua economia, come i servizi fiscali del governo, il finanziamento della catena di approvvigionamento, i sistemi di identità digitale e altri servizi governativi. Di conseguenza, ha istituito il National Blockchain Technology Innovation Center per svolgere ricerche e sviluppo su come il paese possa aumentare i casi d’uso della blockchain.</p>
<p><strong>Quale paese è in testa nel settore blockchain? </strong><br>Recenti dati hanno mostrato che il Giappone è il paese leader nell’uso della tecnologia blockchain. Il motivo principale è che è il primo paese a estrarre e utilizzare <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> su larga scala. Gli altri paesi leader nell’uso della blockchain sono Svizzera, Cina, Regno Unito, Stati Uniti e Singapore.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<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 ogni caso, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>