SWwgZ292ZXJubyBjaW5lc2UgZGltb3N0cmEgc29zdGVnbm8gYWxsYSBibG9ja2NoYWluIG5vbm9zdGFudGUgbGUgbWlzdXJlIGRpIGRpdmlldG8gZGVsbGUgY3JpcHRvdmFsdXRl

2023-05-23, 08:32

<p><img src="https://gimg2.gateimg.com/blog/1679447253722320711jiami.jpeg" alt=""><br>Il National Blockchain Research Center di Pechino mira a coordinare le attività blockchain che supportano casi d’uso non legati alle criptovalute.</p>
<p>Attraverso il National Blockchain Research Center, la Cina mira a formare oltre 500.000 professionisti del settore blockchain che saranno attivi nella promozione della tecnologia blockchain nel paese.</p>
<p>L’obiettivo del governo cinese è creare un’infrastruttura che sostenga l’applicazione della tecnologia blockchain in vari settori come la sanità.</p>
<p><strong>Parole chiave</strong>: cripto cinese, attività digitali cinesi, divieto di cripto, cripto in Cina, cripto, criptovaluta in Cina, adozione della blockchain</p>
<h2 id="h2-Introduzione617515"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Il governo cinese sta lavorando allo sviluppo di un’infrastruttura e di un sistema blockchain robusti che siano utili al di fuori del settore delle criptovalute. Mentre molti governi e istituzioni si concentrano su asset digitali come criptovalute e token non fungibili, la Cina vuole sfruttare la tecnologia blockchain per rafforzare la propria base industriale e tecnologica. Pertanto, questo articolo illustra come il governo cinese stia sviluppando la tecnologia blockchain per utilizzi non legati alle criptovalute.</p>
<h2 id="h2-La20Cina20inaugura20il20Centro20Nazionale20di20Ricerca20sulla20Blockchain20a20Pechino235640"><a name="La Cina inaugura il Centro Nazionale di Ricerca sulla Blockchain a Pechino" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La Cina inaugura il Centro Nazionale di Ricerca sulla Blockchain a Pechino</h2><p>Il governo cinese ha mostrato la sua volontà di utilizzare e sviluppare la tecnologia blockchain per utilizzi non legati alle criptovalute <a href="https://www.gate.io/blog_detail/2298/china-to-launch-a-national-blockchain-center-development-of-blockchain-tech-in-china" target="_blank">attraverso la creazione del Centro Nazionale di Ricerca</a> che ha già inaugurato a Pechino.</p>
<p>Supportato dal Ministero cinese della Scienza e della Tecnologia, il Centro Nazionale di Ricerca Blockchain collaborerà strettamente con università, istituti di ricerca e aziende tecnologiche per trovare nuovi casi d’uso della blockchain e <a href="https://www.gate.io/pt/blog_detail/2563/countries-that-lead-in-blockchain-adoption" target="_blank">espandere la sua adozione in entrambi</a> il settore pubblico e privato.</p>
<p>L’Accademia di Pechino per la Blockchain e il Calcolo ai Margini, istituto di ricerca sostenuto dal governo noto per lo sviluppo del ChainMaker, guida il Centro Nazionale di Ricerca sulla Blockchain nelle sue iniziative di sviluppo innovativo e blockchain. Anche se ha diversi obiettivi, il suo obiettivo principale è sviluppare e mantenere una rete blockchain a livello nazionale che supporti l’espansione della base industriale cinese.<br><img src="https://gimg2.gateimg.com/image/article/16848305591.png" alt=""><br>La Cina approva il National Blockchain Research Center - SCMP</p>
<p>Per rendere la blockchain una parte centrale della sua trasformazione digitale, la Cina formerà almeno 500.000 professionisti della blockchain che guideranno lo sviluppo del settore digitale. Questo perché la competenza umana è un fattore chiave per l’innovazione, lo sviluppo industriale e il progresso tecnologico. Come notiamo, nonostante <a href="https://www.gate.io/blog_detail/378" target="_blank">il divieto sulle criptovalute in Cina</a> mirano a mantenere la propria posizione di paese leader nelle innovazioni blockchain.</p>
<p>Già la Cina ha compiuto progressi notevoli nell’adozione e nell’uso della tecnologia blockchain, molto avanti rispetto ad altri paesi. Oltre allo sviluppo della sua valuta digitale della banca centrale, l’e-yuan, il governo cinese ha messo i dati di oltre 80 dipartimenti pubblici sulla Catena Chang’an per ‘migliorare efficacemente la sicurezza e l’ordine degli affari governativi e dei dati sociali’.</p>
<p>Nonostante l’ampia adozione della tecnologia blockchain, il governo cinese mantiene il divieto delle attività legate alle criptovalute nel paese. Ad esempio, la Cina non permette il commercio di criptovalute sul suo territorio. Inoltre, non è legale per individui e aziende partecipare all’industria del mining di criptovalute, limitando così l’adozione delle criptovalute nel paese.</p>
<p>Tuttavia, il governo consente l’acquisto e il possesso di token non fungibili (NFT) sotto l’etichetta di “oggetti da collezione digitali”. In modo significativo, i cittadini possono acquistare solo gli NFT utilizzando lo yuan, ma non sono autorizzati a scambiarli per profitto.</p>
<p>Nel 2019, la tecnologia blockchain ha avuto un ruolo centrale nel paese quando il Presidente Xi Jinping ne ha approvato l’adozione per uso industriale. Di conseguenza, il governo vuole che il paese rimanga competitivo in questa tecnologia all’avanguardia. Allo stesso tempo, sembra che la Cina stia permettendo a Hong Kong di adottare criptovalute e altri asset digitali come caso di prova per il paese.</p>
<p>Inoltre, il Centro Nazionale di Ricerca sulla Blockchain <a href="https://www.gate.io/uk/blog_detail/2298/china-to-launch-a-national-blockchain-center-development-of-blockchain-tech-in-china" target="_blank">vuole stabilire una rete blockchain nazionale</a> che collega le blockchain esistenti e consente lo sviluppo cross-chain. Questa visione è stata promulgata dal Ministero dell’Industria e delle Tecnologie dell’Informazione (MIIT) e dall’Amministrazione dello Spazio Cibernetico della Cina (CAC), i due principali regolatori dell’industria tecnologica nel paese, nel 2021.</p>
<p>Come segno che la Cina vuole promuovere le applicazioni non criptovalutarie della blockchain, ha recentemente lanciato il suo mercato NFT regolamentato. Ci sono altre varie iniziative per utilizzare la tecnologia blockchain. Ad esempio, alcune entità vogliono utilizzare Chang’An Chain, una piattaforma open source creata dall’Accademia di Blockchain e Edge Computing di Pechino, per registrare il ciclo di vita del carbonio nel registro pubblico.</p>
<p>Inoltre, i player cinesi del settore sanitario stanno lavorando sul loro blockchain, la Xiaotong Medical Chain, per registrare dati affidabili. In questo modo, varie istituzioni mediche condivideranno le loro informazioni in modo trasparente, sicuro e verificabile.</p>
<p>Leggi anche: <a href="https://www.gate.io/blog_detail/2600/china-pays-salaries-in-digital-yuan" target="_blank">La città cinese di Changshu pagherà gli stipendi in E-Yuan</a></p>
<h2 id="h2-Le20aziende20digitali20cinesi20cercano20rifugio20a20Hong20Kong309382"><a name="Le aziende digitali cinesi cercano rifugio a Hong Kong" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le aziende digitali cinesi cercano rifugio a Hong Kong</h2><p>C’è molto interesse per gli asset digitali e le criptovalute cinesi nel paese. A causa del divieto sulle criptovalute in Cina, molte aziende cinesi di asset digitali stanno cercando rifugio a Hong Kong, dove ci sono regolamenti criptati amichevoli.</p>
<p>Allo stesso modo, alcune delle aziende cripto ben consolidate hanno uffici a Hong Kong e offrono vari servizi. Ad esempio, <a href="/price/huobi-ht" rel="nofollow noopener noreferrer" target="_blank">Huobi</a> operare a Hong Kong. Curiosamente, alcune banche cinesi stanno anche pianificando di offrire vari servizi criptati nella città.</p>
<p>Esempi di banche disposte a offrire servizi cripto nella città sono le filiali di Hong Kong della Bank of Communications, Bank of China e Shanghai Pudong Development Bank. Inoltre, CNHC Group, l’azienda di tecnologia blockchain, è disposta a fornire servizi bancari cripto nella città.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16848306522.png" alt=""><br>Bank of China fornirà servizi criptati a Hong Kong - Seenews</p>
<p>Dopo il crollo delle principali banche degli Stati Uniti che fornivano servizi criptati, le banche di Hong Kong sono disposte a colmare tale vuoto.</p>
<h2 id="h2-Attivit20di20criptovaluta20a20Hong20Kong71849"><a name="Attività di criptovaluta a Hong Kong" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Attività di criptovaluta a Hong Kong</h2><p>Discutiamo brevemente perché alcune aziende preferiscono trasferirsi a Hong Kong. La città ha compiuto progressi nella promozione di asset digitali come le criptovalute. Ad esempio, all’inizio di quest’anno ha messo da parte HK$50 milioni (US$6,4 milioni) per finanziare lo sviluppo dell’industria web3.</p>
<p>In generale, i regolatori di Hong Kong stanno lavorando duramente per attirare le aziende criptate globali al fine di potenziare i settori blockchain e digitali. Le ragioni per cui queste aziende vengono nella città sono il suo chiaro quadro politico sulle criptovalute. Allo stesso modo, lo sforzo concertato della città per promuovere la tecnologia blockchain dà alle imprese criptate la speranza che prospereranno bene a Hong Kong.</p>
<h2 id="h2-Conclusione14727"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Nonostante il divieto della criptovaluta in Cina, il governo cinese sostiene l’espansione della tecnologia blockchain per utilizzi non legati alle criptovalute, come la condivisione dei dati nel settore medico. Il recentemente inaugurato National Blockchain Research Center mira a coordinare l’applicazione della tecnologia blockchain in diversi settori dell’economia. A causa del divieto delle attività legate alle criptovalute nella Cina continentale, molte aziende criptovalutarie stanno pianificando di trasferirsi a Hong Kong.</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. La ripubblicazione dell'articolo sarà consentita a condizione che venga fatto riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali a causa di violazioni del copyright.<br></div><p></p><br></div></div></div>