QXppYXRpc2NoZSBtYXJrdG5pZXV3czogSGV0IGVlcnN0ZSB2ZXJrb29wcHJvYmxlZW0gdm9vciBORlQncw==

2023-03-21, 07:43

<p><img src="https://gimg2.gateimg.com/blog/1679447253155655279redian.jpeg" alt=""><br>Regeringen maken geen gebruik van de digitale eerste verkoop, omdat ze niet kunnen bewijzen dat wanneer digitale inhoud wordt overgedragen, deze ook wordt verwijderd uit de bronmappen of -bestanden.</p>
<p>NFT’s voorkomen dat mensen digitale inhoud die op de blockchain bestaat wijzigen en verwijderen.</p>
<p>Silvergate heeft nagelaten om ‘transparantie en hoogwaardige beveiliging op de NFT-markt’ te handhaven.</p>
<p>De sluiting van Silvergate Bank zal NFT-handelaren in staat stellen over te stappen naar Signature Bank.</p>
<p>Trefwoorden: NFT’s eerste digitale verkoop, NFT’s eerste stap, Aziatische NFT-markt, Probleem met digitale verkoop, File coin, Chinese tokens, China tokens, Silvergate Bank, Signature Bank, NFT-handelaren</p>
<h2 id="h2-Introductie729650"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Het Aziatisch-Pacifisch gebied is een belangrijk onderdeel van de cryptomarkt, aangezien er veel crypto-investeringsactiviteiten zijn, evenals een steeds groeiende cryptogemeenschap. Naast de toename van het gebruik van cryptovaluta is er ook een hoge <a href="https://www.gate.io/uk/blog_detail/2286" target="_blank">interesse in NFT’s</a>.</p>
<p>Echter, de regio staat voor enkele uitdagingen, waaronder de daling van China tokens en het probleem van de digitale verkoop van NFT’s. In dit artikel onderzoeken we hoe blockchain technologie belangrijk is om het probleem van de eerste verkoop voor NFT’s te overwinnen.</p>
<h2 id="h2-China20tokens20presteren20ondermaats675090"><a name="China tokens presteren ondermaats" class="reference-link"></a><span class="header-link octicon octicon-link"></span>China tokens presteren ondermaats</h2><p>Tijdens de eerste maanden van 2023 is er een toename geweest in het aantal Chinese tokens op de blockchain. Deze tokens worden voornamelijk verhandeld op beurzen die niet gereguleerd worden door de overheid. Deze situatie heeft geleid tot een afname van het vertrouwen van crypto-investeerders, omdat zij zich zorgen maken over het investeren in dergelijke tokens.</p>
<p><strong>Lees ook: <a href="https://www.gate.io/blog_detail/1681/how-to-buy-and-store-non-fungible-tokens" target="_blank">Hoe u niet-fungible tokens kunt kopen en opslaan</a> </strong></p>
<p>Als gevolg van het verlies van het vertrouwen van beleggers stonden de meeste Chinese tokens op 1 maart 2023 in het rood. Bijvoorbeeld, de waarde van <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a>, een web3-ecosysteemtoken gebaseerd op het nationale Blockchain Service Network van China, daalde met 8%, terwijl Conflux’s CFX-token, gebruikt door Chinese Dapp-ontwikkelaars, in 24 uur met 12% verloor.<br><img src="https://gimg2.gateimg.com/image/article/16793844431.png" alt=""><br>NEO Cryptocurrency - Medium</p>
<p>Ten slotte, de waarde van <a href="/price/filecoin-fil" rel="nofollow noopener noreferrer" target="_blank">Filecoin</a> De FIL-token van Gate.io daalde ook met 5,5%. Op dit moment is er geen zekerheid over hoe de markt zal reageren naarmate het jaar vordert.</p>
<h2 id="h2-Het20eerste20verkoopprobleem20voor20NFTs141696"><a name="Het eerste verkoopprobleem voor NFT’s" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het eerste verkoopprobleem voor NFT’s</h2><p>Het eerste verkoopprobleem voor NFT’s is een andere uitdaging waar de Aziatische NFT-markt mee te maken heeft. Volgens de leer van de eerste verkoop kunnen individuen en organisaties hun wettelijk verworven auteursrechtelijk beschermde inhoud doorverkopen zonder angst voor juridische stappen.</p>
<p>Met andere woorden, een persoon die een auteursrechterlijk beschermd goed bezit, zoals een academisch leerboek, kan het verkopen zonder toestemming van de eigenaar van het auteursrecht. Daarmee beperkt deze leer van de eerste verkoop het exclusieve recht van de eigenaar van het auteursrecht met betrekking tot de verwijdering van een wettig verkregen goed.</p>
<p><strong>Lees ook: <a href="https://www.gate.io/learn/articles/what-is-nfts-marketplace-aggregator/297" target="_blank">Wat is NFTs Marketplace Aggregator?</a></strong></p>
<p>Op dit moment is het eerste verkoopdoctrine niet van toepassing op digitale overdrachten van inhoud. De reden waarom het eerste verkoopdoctrine niet van toepassing is op digitale inhoud, is het aspect van ontastbaarheid en niet-uitputting van digitale inhoud. Met andere woorden, een individu kan digitale inhoud verspreiden naar zoveel mensen als hij/zij wil.</p>
<p>Evenzo vereist de overdracht van digitale inhoud dat de eigenaar het reproduceert, wat inbreuk maakt op het reproductierecht van de auteursrechthebbende. Het echte probleem is dat wanneer iemand digitale inhoud naar een andere persoon stuurt, hij/zij nog steeds de kopie behoudt omdat deze niet wordt verwijderd.</p>
<p>Daarom kunnen individuen gemakkelijk digitale inhoud kopiëren, waardoor identieke kopieën worden geproduceerd. Als mensen steeds nieuwe kopieën van de digitale inhoud blijven maken, verliezen ze hun waarde omdat ze niet langer schaars zijn. Het probleem van de digitale verkoop komt veel voor in Azië, waar piraterij en diefstal van intellectueel eigendom veel voorkomen.</p>
<p>Het trieste is dat als de overheid het ‘first sale doctrine’ adopteert voor digitale inhoud, de hele secundaire markt illegaal zal worden. Dit komt doordat de oorspronkelijke makers van de inhoud bewijs van eigendom zullen leveren als iemand anders het op de secundaire markt doorverkoopt. In dit g kunnen ze hun intellectuele eigendomsrechten als referentiepunten gebruiken.</p>
<p>Op dit moment zijn de rechtbanken van mening dat er geen manier is om ervoor te zorgen dat wanneer een bestand wordt overgedragen, de originele kopie wordt verwijderd om inbreuk te voorkomen op de rechten van de auteursrechthebbenden.</p>
<h3 id="h3-Dubbele20uitgaven20en20de20blockchain638646"><a name="Dubbele uitgaven en de blockchain" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Dubbele uitgaven en de blockchain</h3><p>Het gebruik van NFT’s kan het mogelijk maken om de eerste verkoopdoctrine in de digitale ruimte te gebruiken. Dit komt omdat mensen geen inhoud kunnen kopiëren of dupliceren die bestaat als niet-fungibele tokens. Wanneer een NFT wordt verkocht, wordt er een permanent record van de transactie gemaakt op de blockchain, wat een bewijs is van eigendom van de inhoud.</p>
<p><strong>Lees ook: <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">Hoe NFT-werken verkopen en de verkoopmethode instellen (op APP)</a>”)</strong></p>
<p>Aangezien de oorspronkelijke eigenaar van een NFT zijn/haar eigendom van de digitale inhoud kan verifiëren, wordt het probleem van dubbele uitgaven voorkomen. Echter, <a href="https://www.gate.io/help/nft/nfts/22845/how-to-sell-nft-works-and-set-the-selling-method-on-app" target="_blank">als de NFT niet verkocht is</a> op de blockchain zal het probleem van dubbe uitgeven bestaan.</p>
<h2 id="h2-Hoe20benvloeden20kwesties20met20betrekking20tot20Silvergate20de20NFTmarkt704196"><a name="Hoe beïnvloeden kwesties met betrekking tot Silvergate de NFT-markt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe beïnvloeden kwesties met betrekking tot Silvergate de NFT-markt?</h2><p>Analisten geloven dat de <a href="https://www.gate.io/blog_detail/2326/silvergate-suspends-crypto-payments-network-and-more" target="_blank">sluiting van Silvergate</a> zal een negatieve invloed hebben op NFT’s. De Silvergate Bank heeft het mogelijk gemaakt voor bedrijven en particulieren om contant geld om te zetten in cryptocurrencies en vice versa. Het bood verschillende diensten aan die betrekking hadden op digitale activa zoals NFT’s. Daarom heeft het geholpen om liquiditeit te brengen in de crypto- en NFT-markten.<br><img src="https://gimg2.gateimg.com/image/article/16793845132.png" alt=""><br>Silvergate Bank - Axios</p>
<p>De sluiting van de bank betekent dat de bedrijven, platforms en individuen die Silvergate gebruikten om hun transacties te verwerken, dat niet langer kunnen doen. Sommige analisten zijn van mening dat sommige van de problemen waarmee Silvergate werd geconfronteerd, verband hielden met de digitale eerste verkoop van NFT’s. Wanneer er geen manier is om het eigendom van de NFT’s te bewijzen, kunnen er dubbele uitgaven plaatsvinden met financiële verliezen tot gevolg. Daarom was er bij Silvergate Bank geen “transparantie en hoogwaardige beveiliging op de NFT-markt”, wat resulteerde in financiële verliezen.</p>
<h2 id="h2-Klanten20van20Silvergate20kunnen20overstappen20naar20Signature20Bank980087"><a name="Klanten van Silvergate kunnen overstappen naar Signature Bank" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Klanten van Silvergate kunnen overstappen naar Signature Bank</h2><p>De sluiting van Silvergate Bank betekent dat de NFT-sector geen directe transacties meer kan uitvoeren met de banksector. Aangezien de samenwerking tussen de NFT-markt en Silvergate is beëindigd, zijn handelaren op zoek naar een geschikt alternatief.</p>
<p>De meest mogelijke alternatief op dit moment is Signature Bank. Onlangs meldde CoinDesk dat de bank nieuwe klanten heeft ontvangen, waaronder NFT-handelaren. Dit betekent dat het crypto-gerelateerde diensten aanbiedt die NFT-handelaren kunnen gebruiken.</p>
<p>Volgens CoinDesk zei Joseph DePaolo, CEO van Signature Bank, dat de bank nieuwe klanten aantrekt en klaar staat om hen betrouwbare hoogwaardige cryptodiensten te bieden.</p>
<h2 id="h2-Conclusie537555"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>De NFT-markt in Azië staat voor verschillende uitdagingen, waaronder het probleem van de eerste verkoop en de dalende waarde van Chinese tokens. De beste oplossing voor het probleem van de eerste digitale verkoop is het gebruik van NFT’s die het probleem van dubbele uitgaven voorkomen. De banken die crypto leveren, moeten zorgen voor transparantie en hoogwaardige beveiliging om financiële verliezen te beperken.</p>
<div class="blog-details-info"><br><div>Auteur:<strong> Mashell C.</strong>, Gate.io onderzoeker<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingsaanbeveling.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw posten van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>