R2F0ZS5pbyBBTUEgbWV0IENhc3BlciAtIEJsb2NrY2hhaW4gdm9vciBkZSBCb3V3ZXJz

<p><img src="https://gimg2.gateimg.com/image/article/16781795471.png" alt=""><br><strong>Tijd: 16 augustus 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Mrinal Manohar, CEO van CasperLabs en Ralf Kubli, Bestuurslid van Casper Association in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële Website: <a href="https://www.casperblockchain.io" rel="nofollow noopener noreferrer" target="_blank">https://www.casperblockchain.io</a></strong></p>
<p><strong>Twitter: <a href="https://twitter.com/Casper_Network" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Casper_Network</a></strong></p>
<p><strong>Volg Casper op <a href="https://discord.com/invite/Q38s3Vh" rel="nofollow noopener noreferrer" target="_blank">Discord</a> en <a href="https://t.me/casperblockchain" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gasten</strong><img src="https://gimg2.gateimg.com/image/article/16781797643.jpg" alt=""><br><strong>Mrinal Manohar — CEO van CasperLabs</strong><br>Mrinal Manohar is een bekende computerwetenschapper en financieel leider. Na het behalen van een Masterdiploma in Computerwetenschappen aan de Carnegie Mellon University, heeft Mrinal tijd doorgebracht bij Bain &amp; Co., Bain Capital en Sagard Holdings, waar hij de TMT-sector van dit $1B+ long-only hedgefonds leidde. Mrinal is al bijna twee decennia een voorstander van open-source computing; hij was een vroege bijdrager aan de <a href="/price/bittorrent-btt" rel="nofollow noopener noreferrer" target="_blank">BitTorrent</a> project, gedolven <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> op de universiteit, en was een investeerder in de vroege fase van het bedrijf, <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, Blockstack, Basis, MakerDAO en vele andere vroege blockchain projecten.</p>
<p><strong>Ralf Kubli - Bestuurslid van Casper Association</strong><img src="https://gimg2.gateimg.com/image/article/16781797902.jpg" alt=""><br>Ralf Kubli is een bestuurslid van de Casper Association. De Casper Association is de beheerder van de <a href="/price/casper-network-cspr" rel="nofollow noopener noreferrer" target="_blank">Casper Netwerk</a>. Ralf begon zich in 2016 te verdiepen in blockchain en heeft een brede achtergrond in technologie en financiën.</p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio688094"><a name="Vraag en antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en antwoord van Gate.io</h2><h3 id="h3-Vraag20120Kunt20u20ons20alstublieft20een20korte20introductie20over20uzelf20geven444898"><a name="Vraag 1: Kunt u ons alstublieft een korte introductie over uzelf geven?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 1: Kunt u ons alstublieft een korte introductie over uzelf geven?</h3><p><strong>Mrinal</strong>: Zeker. Hallo allemaal. Mijn naam is Mrinal Manohar en ik ben de CEO en een van de medeoprichters van CasperLabs. Ik ben zowel een ingenieur als een voormalig Wall Street-investeerder. Na het behalen van een mastertitel in computerwetenschappen aan de Carnegie Mellon University, heb ik tijd doorgebracht bij Bain &amp; Co., Bain Capital en Sagard Holdings, waar ik de TMT-sector van een long-only hedgefonds van meer dan $1 miljard heb geleid. Hoewel we CasperLabs in 2018 hebben opgericht, ben ik al bijna twee decennia een voorstander van open-source computing; ik was een vroege bijdrager aan de <a href="/price/bittorrent-btt" rel="nofollow noopener noreferrer" target="_blank">BitTorrent</a> project, en was een investeerder in het zaadstadium <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a>, Blockstack, Basis, MakerDAO, en vele andere vroege blockchainprojecten.</p>
<p>CasperLabs is begonnen met het bouwen van de Casper-codebase in oktober 2018, en we hebben de Casper Testnet in 2020 gefaciliteerd tot de lancering van het mainnet in maart van vorig jaar. Terwijl de ingenieurs van CasperLabs blijven bijdragen aan nieuwe functies voor de Casper blockchain, is CasperLabs ook een volledig bemand adviesbedrijf dat ondersteuning en diensten biedt aan zijn zakelijke klanten die op Casper bouwen. We werken nauw samen met onze klanten om hun behoeften te begrijpen en hoe we een technische oplossing kunnen bieden die gebruikmaakt van Casper. CasperLabs is een in Zwitserland gevestigde AG en heeft momenteel ongeveer 80 fulltime medewerkers, voornamelijk ontwikkelaars en ingenieurs, die over de hele wereld wonen en werken.</p>
<p>Het is echt geweldig om vandaag hier in de Gate-gemeenschap te zijn. Veel dank aan onze gastheer voor het ontvangen van ons - en aan jullie allemaal voor hier met ons te zijn.</p>
<p><strong>Ralf</strong>: Hi, ik ben Ralf Kubli, een van de bestuursleden van de Casper Association. Mijn professionele loopbaan heb ik doorgebracht in zowel grote bedrijven als in startups. Ik begon in Web2 met het bouwen van websites en het verkennen van de wereld, toen alles nog open en toegankelijk was. Daarna heb ik 18 jaar doorgebracht in grote bedrijven in managementfuncties. Ik kwam voor het eerst in aanraking met Blockchain in 2016 en ben toen lid geworden van een durfkapitaalfirma, en ondersteun nu verschillende Web3-organisaties als bestuurslid.</p>
<p>De Casper Association is de non-profit organisatie gevestigd in Zwitserland, die verantwoordelijk is voor het toezicht op het netwerk en het ondersteunen van de organische evolutie en voortdurende decentralisatie ervan. In wezen zijn wij de bewaker van het opensourceprotocol en als zodanig bevorderen wij de ontwikkeling van het netwerk met het kernteam bij CasperLabs en andere partijen die kunnen bijdragen aan het protocol. Het lidmaatschap van de vereniging bestaat uit onafhankelijke validators die nodes uitvoeren op het <a href="/price/casper-network-cspr" rel="nofollow noopener noreferrer" target="_blank">Casper Netwerk</a>. De Vereniging heeft momenteel 12 fulltime medewerkers.</p>
<p>Ik ben persoonlijk erg enthousiast over <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> en Blockchain - in het bijzonder, Casper! - kan doen om ontwikkelaars, bouwers en makers in staat te stellen echt de wereld te veranderen.</p>
<h3 id="h3-V220Kunt20u20alstublieft20kort20uitleggen20wat20Casper20is20en20ons20wat20vertellen20over20hoe20het20verschilt20van20andere20laag201s935969"><a name="V2: Kunt u alstublieft kort uitleggen wat Casper is en ons wat vertellen over hoe het verschilt van andere laag 1s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V2: Kunt u alstublieft kort uitleggen wat Casper is en ons wat vertellen over hoe het verschilt van andere laag 1s?</h3><p><strong>Mrinal</strong>: Ja, absoluut. <a href="/price/casper-network-cspr" rel="nofollow noopener noreferrer" target="_blank">Casper-netwerk</a> is een blockchain van laag 1 en een Turing-volledig WASM-gebaseerd smart-contractplatform, ondersteund door het enige operationele CBC-Casper Proof-of-Stake (PoS) consensusalgoritme - bekend als Highway (binnenkort te upgraden naar “Zug” in Casper 2.0). Casper is een toestemmingsloze, gedecentraliseerde, openbare blockchain.</p>
<p>Het netwerk is vanaf de basis gebouwd en geoptimaliseerd voor adoptie door bedrijven en ontwikkelaars. Fundamenteel heeft elk commercieel bedrijf en elk project van welke omvang dan ook dat een toepassing wil bouwen met behulp van technologie, controle nodig over hun eigen ketencontracten, ondersteuning voor hun klanten en enkele garanties dat het protocol blijft aanpassen en evolueren naarmate hun behoeften veranderen. Casper stelt bedrijven en ontwikkelaars in staat om naadloos blockchain technologie te integreren in hun bestaande en en ontwikkelingsprocessen. Veel andere Layer 1-protocollen geloven dat een volledige vervanging van de technologiestack nodig is om deze en ‘blockchain klaar’ of ‘blockchain gecentreerd’ te maken. Wij geloven dat het vervangen van bestaande en niet haalbaar is. In plaats daarvan wordt software geleidelijk bestuurd en ontwikkeld, en de Casper-technologie maakt dit mogelijk zonder de veiligheid op te offeren. Dit is mogelijk dankzij de mogelijkheden die de Casper blockchain biedt.<br><img src="https://gimg2.gateimg.com/image/article/16781800844.jpg" alt=""><br>Als een puur proof-of-stake netwerk ondersteunt Casper verschillende netwerkinstallaties. Een bedrijf kan ervoor kiezen om een hybride implementatie van Casper te gebruiken (die mainnet gebruikt) of rechtstreeks mainnet te gebruiken. Belangrijke eigenschappen van hoe de blockchain werkt, kunnen worden geconfigureerd bij het opstarten en worden aangepast door een naadloos upgradeproces. Dit geldt voor alle implementaties van Casper, inclusief mainnet. Het is volledig mogelijk om over te stappen van een privénetwerk naar een hybride, consortium of zelfs openbaar netwerk zonder het netwerk opnieuw te hoeven opstarten. Bedrijven hoeven zich niet vast te voelen zitten aan een specifieke implementatie van de blockchain, ze hebben de flexibiliteit om meer deelnemers toe te voegen naarmate hun behoeften veranderen.<br><img src="https://gimg2.gateimg.com/image/article/16781801255.jpg" alt=""><br>Voorbijgaand aan de flexibiliteit, controle en kracht van het slimme contractplatform is de Casper-technologie gebouwd voor duurzaamheid, met een modulaire architectuur die het mogelijk maakt om consensusprotocollen, uitvoeringsomgevingen en cryptografische versleutelingsschema’s te vervangen. Dit is uiterst belangrijk voor de lange termijn gezondheid van het protocol, en nu er nieuwe onderzoeken en ontwikkelingen plaatsvinden op deze gebieden, is Casper goed gepositioneerd om te profiteren van toekomstige innovatie op dit gebied. Vanwege dit alles werken zowel bedrijven als inheemse blockchainbedrijven met ons samen om op Casper te bouwen.<br><img src="https://gimg2.gateimg.com/image/article/16781801486.jpg" alt=""><br>Hier is een dia waarop de belangrijkste problemen met andere/oudere blockchains van laag één worden weergegeven, evenals de manieren waarop Casper deze problemen oplost.</p>
<h3 id="h3-Q320Ralf20verhuizen20naar20de20Casper20Association20kunt20u20ons20alstublieft20vertellen20wat20momenteel20de20primaire20doelstellingen20van20de20Vereniging20zijn313055"><a name="Q3: Ralf, verhuizen naar de Casper Association, kunt u ons alstublieft vertellen wat momenteel de primaire doelstellingen van de Vereniging zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Ralf, verhuizen naar de Casper Association, kunt u ons alstublieft vertellen wat momenteel de primaire doelstellingen van de Vereniging zijn?</h3><p><strong>Ralf</strong>: Zeker. De Casper Association richt zich in 2022 op vier belangrijke gebieden: netwerkgroei/upgrades, tokens op Casper, NFT’s en R&amp;D. Laat me elk ervan toelichten…</p>
<ol>
<li><p><a href="/price/casper-network-cspr" rel="nofollow noopener noreferrer" target="_blank">Casper Netwerk</a> en ecosysteemontwikkeling via gecoördineerde netwerkupgrades, documentatieressources en educatief materiaal. Validators en node-operators zullen goed geïnformeerd zijn en toegang hebben tot vereiste middelen. Hier is een blik op hoe robuust het Casper-ecosysteem al is!<br><img src="https://gimg2.gateimg.com/image/article/16781802057.jpg" alt=""></p>
</li><li><p>De activering van tokens gebouwd op basis van Casper (vergelijkbaar met ERC20-tokens op <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> maar met betere beveiliging &amp; prestaties), met op standaarden gebaseerde tokenuitgifte, net zo gemakkelijk te gebruiken als ERC-20, kunnen tokens gemakkelijk worden gemaakt op Casper met betere beveiliging en prestaties, en de mechanismen bestaan om dApps efficiënt te brengen van <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en andere ketens.</p>
</li><li><p>Het ondersteunen van de groei van het NFT-ecosysteem op Casper. Wij geloven er sterk in dat NFT’s fundamenteel zullen veranderen hoe economieën functioneren en structurele innovatie zullen stimuleren op manieren die nog niet zijn bedacht. De <a href="/price/casper-network-cspr" rel="nofollow noopener noreferrer" target="_blank">Casper Netwerk</a> zal een belangrijke speler zijn in deze toekomstige infrastructuur vanwege functies die eigen zijn aan de Casper-technologie en die niet beschikbaar zijn op andere blockchains.</p>
</li><li><p>Onderzoek en Ontwikkeling - De vereniging pakt uitdagingen aan waarmee blockchains te maken hebben en zorgt ervoor dat de Casper Blockchain klaar is voor de toekomst. Het waarborgen van decentralisatie, gereedheid voor kwantumcomputing en algemene incentivestructuren zijn cruciaal voor de toekomst.</p>
</li></ol>
<h3 id="h3-Q420Mrinal20je20hebt20genoemd20dat20de20Casper20Blockchain20is20gebouwd20en20geoptimaliseerd20voor20de20acceptatie20door20ontwikkelaars20Kun20je20uitleggen20wat20het20onderscheidend20maakt202020Caspernetwerk2020meer20ontwikkelaarsvriendelijk20en20meer20geschikt20voor20ondernemingen20dan20anderen544853"><a name="Q4: Mrinal, je hebt genoemd dat de Casper Blockchain is gebouwd en geoptimaliseerd voor de acceptatie door ontwikkelaars. Kun je uitleggen wat het onderscheidend maakt?   Casper-netwerk  meer ontwikkelaarsvriendelijk en meer geschikt voor ondernemingen dan anderen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Mrinal, je hebt genoemd dat de Casper Blockchain is gebouwd en geoptimaliseerd voor de acceptatie door ontwikkelaars. Kun je uitleggen wat het onderscheidend maakt? <a href="/price/casper-network-cspr" rel="nofollow noopener noreferrer" target="_blank">Casper-netwerk</a> meer ontwikkelaarsvriendelijk en meer geschikt voor ondernemingen dan anderen?</h3><p><strong>Mrinal</strong> Ja natuurlijk. Veel blockchains vereisen bijvoorbeeld kennis van gepatenteerde programmeertalen om erop te kunnen bouwen. <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> gebruikt Solidity terwijl <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> vereist kennis van Plutus. Casper ondersteunt Rust en Assembly waar de meeste programmeurs met ervaring in bestaande programmeertalen in staat zullen zijn om voort te bouwen op Casper.</p>
<p>Om meer functies te verduidelijken die Casper de keuze maken voor echte zaken…</p>
<p>Contractuitvoering op basis van WASM stelt ontwikkelaars in staat om elke taal naar keuze te gebruiken, in plaats van een nieuwe taal te moeten leren om aan de slag te gaan. Casper biedt slimme contractbibliotheken voor Rust en Assembly.</p>
<p>Voor de blockchain werd alle software gebouwd in een IDE (Integrated Development Environment - zoals Visual Studio). Casper-contracten kunnen binnen deze omgeving worden geschreven, gecompileerd, uitgevoerd en getest. Geen behoefte aan HardHat of Truffle.</p>
<p>Ontwikkelaars kunnen de tooling van hun keuze gebruiken om hun contracten te bouwen en te testen.</p>
<p>Beperkte referenties - het is mogelijk om gegevens veilig te delen tussen contracten.</p>
<p>Gebeurtenisemissie - blockchaingebeurtenisgegevens &amp; transactie-informatie wordt gestreamd vanuit de node in een duwmechanisme in plaats van een trekmethode. en moeten luisteren, analyseren en matchen voor relevante informatie - dit is eenvoudiger dan voortdurend de blockchain bevragen ‘Is mijn transactie al klaar?’ - Denk aan pushmeldingen in plaats van het bevragen van antwoorden van het systeem.</p>
<p>Casper is de enige blockchain met on-chain pakketbeheer. Wanneer een contract op een keten wordt aangemaakt, wordt het ‘geïnstalleerd’ - op dat moment wordt een nieuw pakket gemaakt. Dit is precies hetzelfde patroon als het publiceren van een bibliotheek naar npm bijvoorbeeld. Nieuwe versies van een contract worden automatisch versienummerd. Contractupgrades zijn veilig en gebruiken geen proxycontracten of ingewikkelde ontwerppatronen. Het is ook mogelijk voor contracten die andere contracten aanroepen om zich te ‘vast te koppelen’ aan een specifieke versie van het contract.</p>
<p>Dit is de manier waarop afhankelijkheden vandaag de dag worden beheerd in software. Casper maakt ditzelfde paradigma mogelijk op de blockchain. Contractauteurs kunnen ook specifieke versies inactief maken (verouderd) of zelfs onveranderlijk (niet upgradebaar).</p>
<p>Krachtige accounts met gewogen sleutels - Wijs accounts aan elkaar toe, verleen gewichten voor inzet, sleutelbeheer. Dit maakt gedistribueerde controle en beheer over contracten en accounts mogelijk. Complex organisatorische hiërarchieën en besturingsmodellen kunnen worden uitgedrukt in Casper-accounts en waargenomen op de keten. Accounts kunnen ook code-uitvoering en -opslag ondersteunen. Stel je voor dat je in staat bent om een verwijzing naar alle tokens die je bezit binnen je account op te slaan, of een verwijzing naar alle DeFi-contracten waarmee je hebt geïnteracteerd? Op dit moment is dit op andere blockchains niet mogelijk. Hoewel deze activa nog steeds bestaan ​​in de context van hun bijbehorende slimme contracten, kunnen je accounts in Casper een handvat bevatten, een verwijzing naar deze contracten voor gemakkelijke toegang in de toekomst.</p>
<p>Er komen nog een heleboel meer functies in de Casper 2.0-upgrade, die we zullen communiceren; blijf op de hoogte!</p>
<h3 id="h3-Q520Zoals20we20begrijpen20dat20CasperLabs20zich20voornamelijk20richt20op20Enterprise20Adoption20wat20is20er20met20andere20aspecten20zoals20DeFi20en20NFTs386368"><a name="Q5: Zoals we begrijpen dat CasperLabs zich voornamelijk richt op Enterprise Adoption, wat is er met andere aspecten zoals DeFi en NFT’s?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Zoals we begrijpen dat CasperLabs zich voornamelijk richt op Enterprise Adoption, wat is er met andere aspecten zoals DeFi en NFT’s?</h3><p><strong>Kanton Mrinal</strong>: We begrijpen zeker het belang van beide groeiende segmenten binnen het blockchain-ecosysteem. NFT’s hebben brede toepassingen - ik zie de wereld als vol met niet-vervangbare items. Je kunt een stoel niet in 100 stukjes breken en die stukjes gebruiken om bijvoorbeeld eten te kopen. Het is niet-vervangbaar. NFT’s zijn uitstekend om de wereld om ons heen te vertegenwoordigen - op de blockchain.</p>
<p>We zien NFT’s als iets dat zeer nuttig is in Enterprise om unieke items bij te houden, voor tickets, coupons, KYC enzovoort. Daarom ligt er zoveel focus op op NFT gebaseerde contracten. Het CEP-78-contract van Casper gebruikt een fabriekspatroon; het kan worden gebruikt om veel verschillende soorten NFT-contracten te installeren. Casper NFT’s bieden optionele veranderlijkheid van on-chain metadata, waardoor de NFT’s veranderingen in de status van het bijbehorende actief kunnen volgen. Casper-contracten functioneren als gewone software. Het is aan de contractauteur om te bepalen wat het upgradepatroon is. Omdat de VM op Casper doelgericht is gebouwd, is het mogelijk om te overwegen de NFT-standaard aan de hostkant te brengen, waardoor de transacties sneller, lichter en gas-efficiënter worden.</p>
<p>Er zijn al meerdere marktplaatsen die al integreren met de <a href="/price/casper-network-cspr" rel="nofollow noopener noreferrer" target="_blank">Casper Network</a>; Metacask.io, Dmusic en DGallery, Wise.Art, Friendy.Market, CasperNFT.market en zelfs een van onze zakelijke klanten, IPwe, maakt gebruik van onze NFT-technologie.</p>
<p>We hebben enkele geweldige NFT-mogelijkheden in de pijplijn met betrekking tot bekende merken die zullen worden aangekondigd naarmate ze worden gebouwd, blijf op de hoogte!</p>
<p>Ik laat Ralf ook enkele van de DeFi-implementaties bespreken die op het netwerk worden gebouwd. Ralf: Bedankt, Mrinal. Bij de vereniging zien we NFT’s veel breder dan waarvoor ze vandaag worden gebruikt.</p>
<p>We erkennen dat DeFi belangrijk is om liquiditeit en functionaliteit naar het netwerk te brengen. DotOracle heeft de eerste brug gelanceerd op Casper - een AnySwap-fork die Casper verbindt met BSC. <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>, ETH, AVAX, FTM en andere EVM-compatibele ketens. U kunt de brug vinden bij <a href="https://bridge.dotoracle.network" rel="nofollow noopener noreferrer" target="_blank">https://bridge.dotoracle.network</a>.</p>
<p>Het Ferrum Network-team lanceert ook white-label bruggen voor BSC, ETH en <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a>- en deze zullen binnenkort worden vrijgegeven.</p>
<p>De eerste DEX is live op Gate.io <a href="https://friendly.market" rel="nofollow noopener noreferrer" target="_blank">https://friendly.market</a>- en 3 andere DEX’en bereiden zich voor op de lancering (CasperSwap, WiseSwap, Swappery) in de komende maanden.<br>Er zijn al verpakte stablecoins en verpakte activa beschikbaar op Friendly Market.</p>
<p>Er zal ook een integratie van wrapped stablecoin zijn via de DotOracle-brug, Change.Now en uiteindelijk een native <a href="/price/frax-frax" rel="nofollow noopener noreferrer" target="_blank">Frax</a> implementatie die wordt ontwikkeld op Casper.</p>
<p>Het is mogelijk om alle contracten op mainnet te observeren op <a href="https://cspr.live/contracts" rel="nofollow noopener noreferrer" target="_blank">https://cspr.live/contracts</a>- 151 contracten op mainnet, en 4.800 contracten op testnet. Er wordt veel gebouwd, met productiereleases om de hoek.</p>
<p>Hier is een momentopname van de DeFi-projecten en -infrastructuur die worden gebouwd.<br><img src="https://gimg2.gateimg.com/image/article/16781802418.jpg" alt=""><br>Voor een eenvoudige gebruikerservaring, de <a href="/price/casper-network-cspr" rel="nofollow noopener noreferrer" target="_blank">Casper Network</a> wordt ondersteund door de Torus Wallet (toegankelijk op <a href="https://casper.tor.us/" rel="nofollow noopener noreferrer" target="_blank">https://casper.tor.us/</a>), waarmee gebruikers kunnen communiceren met Casper zonder zich zorgen te hoeven maken over sleutelbeheer. Uphold (toegankelijk op @ <a href="https://uphold.com/" rel="nofollow noopener noreferrer" target="_blank">https://uphold.com/</a>) is ook een populaire on-ramp en locatie om toegang te krijgen tot Casper CSPR.</p>
<p>Bij de Casper Association zijn we erg enthousiast over NFT’s, maar niet alleen in de vorm van afbeeldingen, maar ALLE soorten bestanden, gegevens, maker product, uitvinding, enz. In de komende weken zult u innovaties rond NFT’s op Casper zien, direct toegankelijk voor de gemeenschap. NFT’s zijn te ontdekken op cspr.live, (en de toekomstige Casper Wallet), een eenvoudig te gebruiken mintfunctie zal beschikbaar zijn, met gedecentraliseerde opslag toegankelijk voor elke gebruiker. Binnenkort zal de Association zeer veilige mintopties naar voren brengen voor de <a href="/price/casper-network-cspr" rel="nofollow noopener noreferrer" target="_blank">Casper Network</a>.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io-gemeenschap<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal er juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>