QmVncmlwIHZhbiBkZSBEZUZpLWluZnJhc3RydWN0dXVyOiBaYWwgRGVGaSBkZSB3ZXJlbGQgb3Zlcm5lbWVuPw==

<p><img src="https://gimg2.gateimg.com/blog/165042832718348369crypto101_web.jpg" alt=""></p>
<h3 id="h3-TL20DR644345"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h3><ul>
<li>Decentralized finance is een technologie gebaseerd op de blockchain die peer-to-peer transacties mogelijk maakt.</li><li>Bij DeFi worden smart contracts gebruikt bij het uitvoeren van transacties, terwijl traditionele financiën tussenpersonen hebben.</li><li>DeFi-toepassingen zijn transparant, interoperabel en programmeerbaar</li><li>Voorbeelden van componenten van DeFi zijn ingepakte tokens, stablecoins, yield farming, verzekering, staking, gedecentraliseerde beurzen en leningen.</li></ul>
<h2 id="h2-Introductie123096"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Op dit moment zijn er twee brede financiële en, gedecentraliseerde financiën (DeFi) en traditionele financiën (TradFi). Momenteel bestaan de twee en naast elkaar, maar ze interacteren op verschillende manieren. Het traditionele financiële systeem omvat gecentraliseerde autoriteiten zoals banken en verzekeringsmaatschappijen. In hun operaties gebruiken deze instellingen tussenpersonen, terwijl de gedecentraliseerde sector geen derde partijen gebruikt om transacties te faciliteren. Dit artikel zal zich richten op de infrastructuur van gedecentraliseerde financiën (DeFi).</p>
<h2 id="h2-Wat20is20Gedecentraliseerde20Financin20DeFi846873"><a name="Wat is Gedecentraliseerde Financiën (DeFi?)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is Gedecentraliseerde Financiën (DeFi?)</h2><p>Decentralized Finance, ook wel bekend als DeFi, is een technologie waarbij gebruikers met elkaar communiceren via smart contracts. Ze maken geen gebruik van tussenpersonen zoals banken, verzekeringsmaatschappijen of makelaars om transacties te autoriseren.</p>
<p>In feite is DeFi een technologie gebaseerd op miljoenen computers verspreid over de wereld in plaats van een enkele server. Alle transacties vinden plaats via de blockchain en het internet, die dienstzoekenden en dienstverleners met elkaar verbinden.</p>
<p>De blockchain, die gedecentraliseerd, onveranderlijk, toegankelijk en transparant is, maakt het mogelijk dat veel computers (nodes) alle transactiegegevens opslaan.</p>
<h2 id="h2-DeFi20overzicht656157"><a name="DeFi overzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeFi overzicht</h2><p>Eén van de belangrijke aspecten van de DeFi-infrastructuur zijn de gedecentraliseerde applicaties die gebruikers in staat stellen om met elkaar te verbinden. Wanneer je de applicaties gebruikt, interacteer je direct met een smart contract.</p>
<p>Er zijn verschillende gedecentraliseerde toepassingen, waaronder uitleenplatforms, synthetische activa, stablecoins en gedecentraliseerde beurzen. Deze toepassingen hebben veel dingen gemeen. Zo zijn ze interoperabel, transparant, open source, programmeerbaar en toestemmingsloos. Laten we er een paar van uitleggen.</p>
<p><strong>Transparantie:</strong> De transacties worden op de blockchain vastgelegd en iedereen met internettoegang kan ze bekijken.</p>
<p><strong>Onderling uitwisselbaar: </strong>De gedecentraliseerde applicaties die bestaan op een protocol werken met elkaar samen.</p>
<p><strong>Programmeerbaar: </strong>De ontwikkelaars kunnen de applicaties programmeren zodat ze kunnen communiceren met andere dApps in het ecosysteem.</p>
<p>Open source en Permissionless: Er zijn geen beperkingen op wie de applicaties kan gebruiken, zolang de individuen de vereiste portefeuilles en internetverbinding hebben. De gebruikers kunnen digitale activa zoals stablecoins verzenden of ontvangen.</p>
<h2 id="h2-Het20belang20van20DeFi461786"><a name="Het belang van DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Het belang van DeFi</h2><p>De waarheid is dat DeFi een game changer is in de financiële sector. Het heeft veel toepassingen. Zo maakt het het mogelijk voor mensen om geld te sturen en ontvangen zonder geografische beperkingen. Gebruikers kunnen geld lenen zolang ze voldoen aan de regels van de slimme contracten, zoals een bepaalde hoeveelheid onderpand als ze geld willen lenen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16757544261.png" alt=""><br>Slimme contracten - Inc42</p>
<p>Individuen kunnen ook hun digitale activa uitlenen, zoals stablecoins, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> en Ether (ETH) aan andere mensen te sturen en rente te verdienen. Bovendien geven de cryptocurrencies investeerders de kans om op verschillende manieren te investeren, zoals het sparen van hun tokens en munten.</p>
<p>Zoals u opmerkt, biedt DeFi nut in verschillende sectoren van de economie, zoals verzekeringsdiensten, vermogensbeheer, yield farming, lenen en uitlenen en de gamingsector. DeFi lost in wezen ernstige problemen op die bestaan ​​in de traditionele financiële sector.</p>
<h2 id="h2-Welke20problemen20lost20DeFi20op440197"><a name="Welke problemen lost DeFi op?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke problemen lost DeFi op?</h2><p>In feite maakt DeFi gebruik van peer-to-peer netwerken bij het uitvoeren van zakelijke transacties. Wat dit betekent is dat DeFi-instellingen geen tussenpersonen gebruiken die veel geld kosten en veel vertragingen veroorzaken. Als gevolg hiervan worden belangrijke problemen die inherent zijn aan het traditionele financiële systeem, zoals inefficiëntie en beperkte toegang tot financiële middelen voor bepaalde delen van de samenleving, uitgeroeid.</p>
<p>Het traditionele financiële systeem is buitengewoon inefficiënt omdat er tussenpersonen zijn. De tussenpersonen brengen hoge kosten in rekening en hanteren bureaucratische procedures. Bijvoorbeeld, wanneer een investeerder een activum wil verhandelen, is de procedure tijdrovend. Met DeFi is de uitvoering en afwikkeling van de transactie vrijwel direct en gelijktijdig.</p>
<p>Veel mensen hebben geen toegang tot bepaalde financiële middelen in TradeFi. Dit komt doordat er verschillende beperkingen zijn. Bijvoorbeeld, de gebruikers moeten banken hebben, onderpand hebben en aan bepaalde wettelijke vereisten voldoen, zoals het hebben van nationale identiteitskaarten. Aangezien meer dan 1,78 miljard mensen wereldwijd geen bankrekening hebben, kunnen zij geen toegang krijgen tot de financiële middelen. DeFi vereist echter niet dat mensen banken hebben of aan de meeste van deze beperkende vereisten voldoen.</p>
<p>Er is een gebrek aan interoperabiliteit binnen de traditionele financiële sector. Dit komt doordat er veel barrières zijn die verschillende instellingen binnen het oude financiële systeem ervan weerhouden om met elkaar te communiceren. Bijvoorbeeld, iemand die een handelsaccount online wil openen, moet mogelijk geld overboeken van zijn/haar bank. Dit kost veel tijd en vereist geld. DeFi-toepassingen kunnen echter gemakkelijk met elkaar communiceren.</p>
<h2 id="h2-DeFiapplicaties20en20componenten749992"><a name="DeFi-applicaties en componenten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeFi-applicaties en componenten</h2><p>DeFi heeft verschillende toepassingen, tools en componenten. Laten we een korte opsomming geven van deze componenten, waaronder stablecoins, gedecentraliseerde exchanges en ingepakte munten.</p>
<h3 id="h3-DeFi20lenen20en20uitlenen20388086"><a name="DeFi lenen en uitlenen :" class="reference-link"></a><span class="header-link octicon octicon-link"></span><a href="https://www.gate.io/lend-earn" target="_blank">DeFi lenen en uitlenen</a>:</h3><p>Individuen hebben de mogelijkheid om hun geld uit te lenen aan mensen die het willen lenen. De leners moeten rente betalen voor het gebruik van de middelen, meestal in de vorm van stablecoins.</p>
<p><strong>Gedecentraliseerde beurzen (Dexs): </strong>Gedecentraliseerde beurzen stellen mensen in staat om hun cryptocurrencies uit te wisselen <a href="https://www.gate.io/help/guide/sacurity/22495/How-to-Obtain-KYC-ID-Verification" target="_blank">zonder noodzaak voor KYC</a>. Dexs zijn ook toestemmingsloos en stellen gebruikers in staat om hun activa anoniem te verhandelen.</p>
<p><strong>Stablecoins: </strong>Dit zijn cryptocurrencies waarvan de waarden constant zijn omdat ze gekoppeld zijn aan andere activa zoals goud en <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>. De meeste stablecoins zijn bijvoorbeeld gekoppeld aan de Amerikaanse dollar. In sommige glen is de prijs van sommige <a href="https://www.gate.io/price/[Tether](https://www.gate.io/trade/USDT_USDT" target="_blank">stablecoins blijven constant</a>-USDT “stablecoins blijven constant”) als gevolg van algoritmen die hun vraag en aanbod beheersen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16757543072.png" alt=""><a href="https://www.gate.io/trade/USDT_USDT" target="_blank">Tether</a> USDT is een populaire stablecoin- Cryptonomist</p>
<p>Yield farming: Dit omvat investeerders die hun cryptocurrencies inzetten om rente te verdienen. Zo verdienen ze passief inkomen zonder veel moeite en met zeer weinig risico.</p>
<p><strong>Verpakte munten:</strong> Dit zijn cryptocurrencies die andere munten vertegenwoordigen en bestaan op verschillende blockchains. Dit is belangrijk omdat het de interoperabiliteit vergroot, de adoptie van cryptocurrencies bevordert en leidt tot snelle transacties in sommige situaties. Bijvoorbeeld, wrapped <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>(wBTC) is een token die vertegenwoordigt <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> maar bestaat op de <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> blockchain. Het behoudt dezelfde waarde als <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a>.</p>
<p><strong>Voorspellingsmarkten:</strong> Voorspellingsmarkten zijn platforms waar mensen voorspellingen doen over mogelijke uitkomsten van bepaalde gebeurtenissen of activiteiten. De weddenschappen betreffen terreinen als sport, handel in forex en cryptocurrency of politiek. Bijvoorbeeld wedden sportfans op de mogelijke uitkomst van voetbalwedstrijden.</p>
<p><strong>Vermogensbeheer: </strong>Gebruikers hebben nu manieren om hun activa op een transparante manier te beheren via DeFi. Ze kunnen hun digitale activa gemakkelijk overdragen of verkopen zonder gebruik te maken van derden. Ze kunnen ook de activa kopen die ze nodig hebben zonder verplichtingen.</p>
<p><strong>E-wallets:</strong> Digitale portemonnees, ook wel e-wallets genoemd, helpen mensen om met verschillende applicaties te communiceren. Deze wallets functioneren onafhankelijk van crypto exchanges en andere dApps. Kortom, de <a href="https://www.gate.io/blog_detail/1280/The-top-7-best-crypto-wallets" target="_blank">portefeuilles stellen u in staat om controle te hebben over uw digitale activa</a> aangezien u de privésleutels bezit.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672367740screenshot-20221230-103526.png" alt=""></p>
<p>Andere componenten en toepassingen: De lijst van DeFi<br>De lijst van toepassingen, componenten en tools is lang. Afgezien van degenen die we hierboven hebben besproken, hebben we ook verzekeringen, gaming-industrie-apps, DeFi-bankieren en nog veel meer.</p>
<h2 id="h2-DeFi20versus20traditionele20FinTechinfrastructuur72460"><a name="DeFi versus traditionele FinTech-infrastructuur" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeFi versus traditionele FinTech-infrastructuur</h2><p>Zoals we eerder hebben gezegd, zijn er duidelijke verschillen tussen traditionele financiering en DeFi. Bij traditionele financiering voeren gebruikers langdurige processen uit om zich te registreren en goedkeuring te krijgen om hun diensten te gebruiken. Helaas zijn er ook vooroordelen en discriminatie wat betreft de begunstigden.</p>
<p>Toch is het onboardingproces met DeFi heel eenvoudig. De gebruiker heeft alleen een digitale portemonnee nodig om te communiceren met DeFi-applicaties. De platforms voeren geen verificaties of achtergrondcontroles uit. Racecapital gebruikt een eenvoudige tabel om TradeFi en DeFi te vergelijken.<br><img src="https://gimg2.gateimg.com/image/article/1672367851screenshot-20221230-103720.png" alt=""></p>
<p>Verschillen tussen TradeFi en DeFi - Racecapital</p>
<p>Er zijn verschillende verschillen tussen traditionele financiën en gedecentraliseerde financiering. DeFi heeft echter de overhand op traditionele financiën. In de traditionele financiële sector houden de instellingen bijvoorbeeld de activa vast, terwijl in DeFi de gebruikers de bewaring hebben over hun activa.</p>
<p>De traditionele financiële sector maakt gebruik van fiatvaluta, terwijl DeFi digitale activa zoals stablecoins heeft. In TradeFi zijn er tussenpersonen, maar in DeFi zijn er slimme contracten. De traditionele financiële sector maakt gebruik van clearinghuizen, terwijl DeFi slimme contracten gebruikt om de transacties uit te voeren. Hoewel er aan beide kanten onderpand bestaat, gebruikt DeFi overcollateralisatie om geleende activa te beveiligen.</p>
<h2 id="h2-DeFitoepassingen988639"><a name="DeFi-toepassingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>DeFi-toepassingen</h2><p>Blockchains kunnen verschillende gedecentraliseerde applicaties hebben op basis van de producten en diensten die ze aanbieden. Bovendien hebben sommige blockchains verschillende lagen zoals de basislaag en laag-2. De basislaag kan verschillende applicaties hosten, zoals lening- en vermogensbeheer-dApps. De volgende diagram toont de verschillende applicaties die bestaan op de <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> blockchain en Ethereum.</p>
<p>Sommige blockchains zoals Ethereum hebben layer-2 blockchains. De layer-2 blockchains bieden schaaloplossingen voor de layer-1 chains en voeren de transacties meestal offline uit. <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> en Arbitrum zijn voorbeelden van layer-2 blockchains die bestaan op het Ethereum blockchain.</p>
<h2 id="h2-De20toekomst20van20gedecentraliseerde20financile20toepassingen763180"><a name="De toekomst van gedecentraliseerde financiële toepassingen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De toekomst van gedecentraliseerde financiële toepassingen</h2><p>Hoewel DeFi betere functies en componenten lijkt te hebben, heeft het nog steeds verbeteringen nodig. Vooral de ontwikkelaars kunnen zich richten op toekomstige toepassingen om ze meer gebruikersvriendelijk te maken en hun bruikbaarheid te vergroten.</p>
<h3 id="h3-Consumententoepassingen380384"><a name="Consumententoepassingen:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Consumententoepassingen:</h3><p>De toekomst van DeFi zou consumententoepassingen moeten omvatten die de gebruikerservaring verbeteren, aangezien de gebruikers niet rechtstreeks met het onderliggende protocol interageren. Dit kan de front-ends van de DeFi-ruimte vereenvoudigen en de gebruikerservaring verbeteren.</p>
<h3 id="h3-Klantrelatiebeheer20CRM499962"><a name="Klantrelatiebeheer (CRM):" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Klantrelatiebeheer (CRM):</h3><p>Op dit moment maakt DeFi geen gebruik van customer relationship management, omdat het geen persoonlijke informatie van de gebruikers verzamelt. Dit is goed omdat het de privacy verbetert. Als DeFi echter CRM gebruikt, zullen klanten producten en diensten krijgen die het beste aansluiten bij hun behoeften en voorkeuren.</p>
<p>Er zijn geen meldingen in de DeFi-sector. In de toekomst zullen meldingen de communicatie met de gebruikers verbeteren.</p>
<h3 id="h3-Transactie20terugdraaiingen901324"><a name="Transactie terugdraaiingen:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Transactie terugdraaiingen:</h3><p>Op dit moment kan een gebruiker een transactie niet ongedaan maken als hij/zij een fout maakt bij het verwerken ervan. Transactie terugdraaiingen zullen gebruikers helpen om de transacties ongedaan te maken die ze per ongeluk hebben uitgevoerd.</p>
<h3 id="h3-Identiteit952409"><a name="Identiteit:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Identiteit:</h3><p>In DeFi maken gebruikers hun transacties anoniem. Dit heeft ertoe geleid dat sommige kwaadwillende partijen DeFi-platforms gebruiken voor het uitvoeren van illegale zakelijke activiteiten zoals drugshandel. Vanwege deze pseudonimiteit is het zeer moeilijk voor wetshandhavingsinstanties om de daders op te sporen en te arresteren. Daarom zou er in de toekomst een manier moeten zijn om kwaadwillende partijen zoals hackers te identificeren.</p>
<h2 id="h2-Conclusie54998"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Decentrale financiën (DeFi) transacties vinden plaats op de blockchain en vereisen een internetverbinding. DeFi verschilt van traditionele financiën doordat het geen tussenpersonen betrekt. Aan de andere kant betrekt TradeFi derde partijen bij het uitvoeren van sommige transacties. Ook maakt DeFi gebruik van slimme contracten die peer-to-peer transacties mogelijk maken.</p>
<h2 id="h2-Veelgestelde20vragen883723"><a name="Veelgestelde vragen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen</h2><h3 id="h3-Wat20zijn20de20componenten20van20gedecentraliseerde20financiering969960"><a name="Wat zijn de componenten van gedecentraliseerde financiering?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn de componenten van gedecentraliseerde financiering?</h3><p>DeFi-uitlenen en lenen, gedecentraliseerde beurzen, stablecoins, opbrengstkweken, ingepakte munten en e-wallets zijn onderdelen van DeFi.</p>
<h3 id="h3-Wat20is20DeFiinfrastructuur623868"><a name="Wat is DeFi-infrastructuur?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is DeFi-infrastructuur?</h3><p>DeFi-infrastructuur is het blockchainnetwerk dat slimme contracten ondersteunt.</p>
<h3 id="h3-Wat20zijn20de20kenmerken20van20DeFiportefeuilles535928"><a name="Wat zijn de kenmerken van DeFi-portefeuilles?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn de kenmerken van DeFi-portefeuilles?</h3><p>DeFi-portefeuilles zijn niet-custodiaal, op sleutels gebaseerd, toegankelijk en compatibel met slimme contracten.</p>
<h3 id="h3-Wat20zijn20DeFitools488436"><a name="Wat zijn DeFi-tools?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat zijn DeFi-tools?</h3><p>DeFi-tools zijn de software die nodig is om toegang te krijgen tot DeFi-diensten.</p>
<h3 id="h3-Wat20is20de20ruggengraat20van20DeFi200756"><a name="Wat is de ruggengraat van DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de ruggengraat van DeFi?</h3><p>De ruggengraat van DeFi is het slimme contract.</p>
<div><br><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 standpunten van de onderzoeker en vormt geen enkele beleggingsaanbevelingen.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>