Tm90aXppZSBzdWkgbWVyY2F0aSBhc2lhdGljaTogaWwgcHJvYmxlbWEgZGVsbGEgcHJpbWEgdmVuZGl0YSBwZXIgTkZU

2023-03-21, 07:43

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""><br>I governi non stanno utilizzando la vendita digitale di prima mano poiché non possono dimostrare che quando i contenuti digitali vengono trasferiti vengono anche eliminati dalle cartelle o file di origine.</p>
<p>Gli NFT impediscono alle persone di modificare ed eliminare contenuti digitali che esistono sulla blockchain.</p>
<p>Silvergate non è riuscito a mantenere ‘trasparenza e sicurezza di alto livello nel mercato NFT’.</p>
<p>La chiusura di Silvergate Bank permetterà ai trader di NFT di passare a Signature Bank.</p>
<p>Parole chiave: NFT prima vendita digitale, NFT primo passo, mercato NFT asiatico, Problema di vendita digitale, File coin, Token cinese, Token cinese, Banca Silvergate, Banca Signature, Trader NFT</p>
<h2 id="h2-Introduzione206884"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>La regione Asia-Pacifico è una parte importante del mercato delle criptovalute in quanto vi sono molte attività di investimento in criptovalute e una comunità cripto in continua crescita. Oltre all’aumento dell’adozione delle criptovalute, vi è anche un’alta <a href="https://www.gate.io/uk/blog_detail/2286" target="_blank">interesse per gli NFT</a>.</p>
<p>Tuttavia, la regione sta affrontando alcune sfide che includono il declino dei token cinesi e il problema della vendita digitale di NFT. In questo articolo esploriamo quanto sia importante la tecnologia blockchain per superare il problema della vendita iniziale per gli NFT.</p>
<h2 id="h2-I20token20cinesi20stanno20sottoperformando834664"><a name="I token cinesi stanno sotto-performando" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I token cinesi stanno sotto-performando</h2><p>Durante i primi mesi del 2023 c’è stato un aumento del numero di token cinesi sulla blockchain. Questi token sono stati scambiati principalmente su scambi non regolamentati dal governo. Tale situazione ha portato a una diminuzione della fiducia degli investitori in criptovalute poiché le persone sono preoccupate di investire in tali token.</p>
<p><strong>Leggi anche: <a href="https://www.gate.io/blog_detail/1681/how-to-buy-and-store-non-fungible-tokens" target="_blank">Come acquistare e conservare token non fungibili</a> </strong></p>
<p>A causa della perdita di fiducia degli investitori, la maggior parte dei token cinesi erano in rosso il 1 marzo 2023. Ad esempio, il valore di <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a>, un token dell’ecosistema <a href="/web3" target="_blank" class="blog_inner_link">web3</a> basato sulla Blockchain Service Network nazionale della Cina, è sceso dell’8%, mentre il token CFX di Conflux, utilizzato dagli sviluppatori di Dapp in Cina, ha registrato una perdita del 12% nelle ultime 24 ore.<br><img src="https://gimg2.gateimg.com/image/article/16793844431.png" alt=""><br>Criptovaluta <a href="/price/neo-neo" target="_blank" class="blog_inner_link">NEO</a> - Medium</p>
<p>Infine, il valore di <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> Anche il token FIL di ’s è sceso del 5,5%. Al momento, non c’è certezza su come il mercato reagirà nel corso dell’anno.</p>
<h2 id="h2-Il20problema20della20prima20vendita20per20gli20NFT693712"><a name="Il problema della prima vendita per gli NFT" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il problema della prima vendita per gli NFT</h2><p>Il primo problema di vendita per gli NFT è un’altra sfida che il mercato asiatico degli NFT sta affrontando. Secondo il principio della prima vendita, individui e organizzazioni possono rivendere i propri contenuti protetti da copyright legalmente acquisiti senza timore di contenzioso.</p>
<p>In altre parole, un individuo che possiede una copia protetta da copyright di un bene, come ad esempio un libro di testo accademico, può venderlo senza il permesso del proprietario del copyright. Pertanto, questo principio della prima vendita limita il diritto esclusivo del proprietario del copyright riguardo allo smaltimento di un bene acquisito legalmente.</p>
<p><strong>Leggi anche: <a href="https://www.gate.io/learn/articles/what-is-nfts-marketplace-aggregator/297" target="_blank">Cos’è l’aggregatore del mercato NFT?</a></strong></p>
<p>Tuttavia, al momento il principio della prima vendita non si applica ai trasferimenti digitali di contenuti. Il motivo per cui il principio della prima vendita non si applica ai contenuti digitali è l’aspetto dell’intangibilità e della non esaustività dei contenuti digitali. In altre parole, un individuo può distribuire contenuti digitali a quante persone desidera.</p>
<p>Analogamente, il trasferimento di contenuti digitali richiede al proprietario di riprodurlo, violando il diritto di riproduzione del proprietario del copyright. Ora, il vero problema è che quando qualcuno invia contenuti digitali a un’altra persona, mantiene comunque una copia poiché non viene eliminata.</p>
<p>Pertanto, le persone possono facilmente copiare i contenuti digitali, producendo così copie identiche. Se le persone continuano a fare nuove copie dei contenuti digitali, ne perdono il valore poiché non sono più scarsi. Il problema della vendita digitale è comune in Asia, dove la pirateria e il furto di proprietà intellettuale sono diffusi.</p>
<p>La cosa triste è che se il governo adotta il principio della prima vendita per i contenuti digitali, l’intero mercato secondario diventerà illegale. Questo perché i creatori originali dei contenuti forniranno la prova di proprietà se qualcun altro lo rivende sul mercato secondario. In questo caso, possono utilizzare le loro IP come punti di riferimento.</p>
<p>Attualmente, i tribunali ritengono che non vi sia modo di garantire che quando un file viene trasferito la copia originale venga eliminata al fine di evitare violazioni dei diritti dei proprietari dei diritti d’autore.</p>
<h3 id="h3-Double20spending20e20la20blockchain488756"><a name="Double spending e la blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Double spending e la blockchain</h3><p>L’uso degli NFT può rendere possibile l’utilizzo della dottrina della prima vendita nello spazio digitale. Ciò perché le persone non possono copiare o duplicare i contenuti che esistono come token non fungibili. Quando un NFT viene venduto, viene creato un registro permanente della transazione sulla blockchain, che costituisce una prova di proprietà del contenuto.</p>
<p><strong>Leggi anche: <a href="https://www.gate.io/article/22845 &quot;How to Sell NFT Works and Set the Selling Method (on APP" rel="nofollow noopener noreferrer" target="_blank">Come vendere opere NFT e impostare il metodo di vendita (sull’APP)</a>”)</strong></p>
<p>Poiché il proprietario originale di un NFT può verificare la sua proprietà del contenuto digitale, ciò previene il problema del double spending. Tuttavia, <a href="https://www.gate.io/help/nft/nfts/22845/how-to-sell-nft-works-and-set-the-selling-method-on-app" target="_blank">se l’NFT non viene venduto</a> sulla blockchain il problema del double-spending esisterà.</p>
<h2 id="h2-Come20le20questioni20legate20a20Silvergate20influenzano20il20mercato20NFT720656"><a name="Come le questioni legate a Silvergate influenzano il mercato NFT?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come le questioni legate a Silvergate influenzano il mercato NFT?</h2><p>Gli analisti ritengono che il <a href="https://www.gate.io/blog_detail/2326/silvergate-suspends-crypto-payments-network-and-more" target="_blank">chiusura di Silvergate</a> avrà un impatto negativo sugli NFT. La Silvergate Bank ha reso possibile per le aziende e i privati convertire denaro in criptovalute e viceversa. Ha fornito diversi servizi che coinvolgevano asset digitali come gli NFT. Pertanto, ha contribuito ad aumentare la liquidità nei mercati delle criptovalute e degli NFT.<br><img src="https://gimg2.gateimg.com/image/article/16793845132.png" alt=""><br>Silvergate Bank - Axios</p>
<p>La chiusura della banca significa che le aziende, le piattaforme e gli individui che hanno utilizzato Silvergate per elaborare le loro transazioni non possono più farlo. Alcuni analisti ritengono che alcuni dei problemi che Silvergate ha dovuto affrontare fossero legati alla prima vendita digitale di NFT. Quando non c’è modo di dimostrare la proprietà degli NFT, può verificarsi una doppia spesa con conseguenti perdite finanziarie. Pertanto, con Silvergate Bank non c’era “trasparenza e sicurezza di fascia alta nel mercato NFT”, il che ha comportato perdite finanziarie.</p>
<h2 id="h2-I20clienti20di20Silvergate20possono20passare20a20Signature20Bank941754"><a name="I clienti di Silvergate possono passare a Signature Bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I clienti di Silvergate possono passare a Signature Bank</h2><p>La chiusura della Silvergate Bank significa che il settore NFT non può più effettuare transazioni dirette con il settore bancario. Poiché la cooperazione tra il mercato NFT e Silvergate è terminata, i trader stanno cercando un’alternativa adatta.</p>
<p>L’alternativa più probabile al momento è Signature Bank. Di recente, CoinDesk ha riportato che la banca ha acquisito nuovi clienti, tra cui i trader di NFT. Ciò significa che offre servizi correlati alle criptovalute che i trader di NFT possono utilizzare.</p>
<p>Secondo CoinDesk, Joseph DePaolo, CEO di Signature Bank, ha dichiarato che la banca sta attirando nuovi clienti ed è pronta a fornire loro servizi cripto affidabili e di alta qualità.</p>
<h2 id="h2-Conclusione148133"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>Il mercato NFT Asia sta affrontando diversi problemi, tra cui il problema della prima vendita e la diminuzione dei valori dei token cinesi. La soluzione migliore al problema della vendita digitale iniziale è utilizzare gli NFT che impediscono la sfida della doppia spesa. Le banche che forniscono criptovalute dovrebbero garantire trasparenza e sicurezza di alto livello per limitare le perdite finanziarie.</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 tutti i casi, verranno intraprese azioni legali a causa della violazione del copyright.<br></div><p></p></div></div></div>