RGUgcHJlc2lkZW50IHZhbiBSaXBwbGUgdm9vcnNwZWx0IGRvbWluYW50aWUgdmFuIERlRmktbmFsZXZpbmcgaW4gMjAyNA==

2024-02-22, 10:47

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TL20DR93884"><a name="[TL; DR]" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL; DR]</h2><p>De DeFi-sector zal groeien als crypto-bedrijven hun regelgevende compliance versterken.</p>
<p>De Verenigde Staten heeft de definities van “dealer” en “handelaar in overheidseffecten” opnieuw gedefinieerd om meer toezicht te krijgen op de cryptosector.</p>
<p>De gemiddelde omzet per gebruiker op de DeFi-markt zal naar verwachting $1.378 bereiken in 2024.</p>
<h2 id="h2-Introductie822579"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>De president van Ripple heeft meer inzicht gegeven in de juridische ontwikkelingen in 2024 en de vooruitzichten van DeFi-naleving aan bestaande en opkomende crypto-regelgeving. Dit komt nadat veel regeringen wereldwijd hebben erkend dat er behoefte is aan duidelijke crypto-regelgeving om innovatie te bevorderen en burgers te beschermen tegen illegale cryptografische activiteiten.</p>
<p>In deze analyse gaan we in op de voorspelling van Monica Long, de president van Ripple, over belangrijke ontwikkelingen in de cryptocurrency sector in 2024. We zullen ook de recente verandering in de wetgeving in de Verenigde Staten met betrekking tot crypto onderzoeken.</p>
<h2 id="h2-De20snelle20groei20en20evolutie20van20de20DeFisector114103"><a name="De snelle groei en evolutie van de DeFi-sector" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De snelle groei en evolutie van de DeFi-sector</h2><p>In 2024 ligt de belangrijkste focus van Ripple op naleving van verschillende wettelijke bepalingen die van toepassing zijn op de DeFi-sector. Sterker nog, Monica Long, de president van Ripple, denkt dat naleving van DeFi dominantie een van de cryptotrends zal worden in 2024, wat zal helpen om het vertrouwen van investeerders op te bouwen en de steun van overheden aan te trekken.</p>
<p>Wettelijke naleving is erg belangrijk in deze periode, nadat veel gevestigde crypto-projecten zoals TerraUSD en FTX Exchange in de afgelopen twee jaar zijn ingestort. Het andere verontrustende is het hoge aantal faillissementszaken, zoals die van Celsius, BlockFi en Voyager, die zich hebben voorgedaan in 2023.</p>
<p>De verschillende faillissementszaken en ineenstortingen van cryptoprojecten hebben onzekerheid gecreëerd in de DeFi-sector. Het vertrouwen van investeerders werd verder ondermijnd door de wijdverbreide crypto-onderdrukkingen in de Verenigde Staten. Daarom heeft Long opgeroepen tot naleving van regelgeving om de gezondheid en het vertrouwen in de sector te herstellen.</p>
<p>Belangrijker nog, zei Long dat Ripple zich richt op het ontwikkelen van innovatieve technologieën die voldoen aan regelgevingsnormen om investeerders te beschermen en de stabiliteit van de cryptobranche te bevorderen.</p>
<p>Long is ook van mening dat door het volgen van regelgeving de DeFi-sector meer verbonden zal raken met de traditionele financiële sector, wat de groei zal stimuleren. “In 2024 zal crypto de speculatieve hypecycli doorbreken die sindsdien de booms en busts voor de industrie hebben bepaald <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Het grootste doorbraak in 2024 zal pionierswerk zijn op het gebied van naleving voor gedecentraliseerde financiering, <a href="https://cointelegraph.com/news/defi-compliance-top-industry-trend-2024-says-ripple-president" rel="nofollow noopener noreferrer" target="_blank">Lang zei</a>.</p>
<p>Ze voegde eraan toe: ‘De weg voorwaarts is een gelukkig huwelijk, en dat is wat we altijd hebben geloofd. Je kunt de manier waarop de samenleving beweegt, beheert, tokeniseert en waarde opslaat niet veranderen als je de fundamenten en geschiedenis van het probleem niet begrijpt.’</p>
<h2 id="h2-Realworld20Utility20en20Groei20van20DeFi549596"><a name="Real-world Utility en Groei van DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Real-world Utility en Groei van DeFi</h2><p>In een <a href="https://cointelegraph.com/news/defi-compliance-top-industry-trend-2024-says-ripple-president" rel="nofollow noopener noreferrer" target="_blank">interview met Cointelegraph Long</a> handhaaft dat het werkelijke nut van DeFi de adoptie en groei in de nabije toekomst zal stimuleren. Dit komt omdat de fase van hype en speculatie die is aangewakkerd door initiële muntenaanbiedingen en niet-fungibele tokens tot een einde komt.</p>
<p>De nieuwe DeFi-inspanning hangt niet alleen af van regelgevende naleving, maar ook van integratie met bestaande en zoals TradFi en kunstmatige intelligentie. Analisten geloven al dat DeFi zichtbare groei zal ervaren in 2024. Volgens <a href="https://www.coingecko.com/en/categories/decentralized-finance-defi" rel="nofollow noopener noreferrer" target="_blank">CoinGecko</a> De DeFi-sector heeft een marktkapitalisatie van meer dan $79,5 miljard.</p>
<p>Zulk een astronomische groei van DeFi in minder dan twee decennia heeft de aandacht van toezichthouders getrokken, waardoor zij oproepen tot regulering van de cryptomarkt.</p>
<p>Er zijn verschillende factoren die DeFi-groei in 2024 en daarna kunnen stimuleren. Allereerst is de toename van de toegang tot gedecentraliseerde financiële diensten van cruciaal belang voor de groei van de sector. Dit komt doordat DeFi-diensten transparanter, inclusiever en toegankelijker zijn dan traditionele financiële diensten.</p>
<p>Als voorbeeld zijn gedecentraliseerd lenen, handelen en lenen toegankelijker in DeFi dan in de traditionele financiële sector. Opmerkelijk genoeg bieden zowel gedecentraliseerde uitwisselingsplatforms als gecentraliseerde cryptoprotocollen dergelijke producten aan. Bovendien zal de ontwikkeling van nieuwe toepassingen en gebruiksscenario’s de groei van de sector verder bevorderen.</p>
<p>Met de huidige ontwikkelingen, <a href="https://www.statista.com/outlook/fmo/digital-assets/defi/worldwide" rel="nofollow noopener noreferrer" target="_blank">Statista voorspelt</a> dat de omzet uit DeFi naar verwachting een jaarlijkse groeisnelheid van 9,07% zal overschrijden tussen 2024 en 2028, wat leidt tot ‘een totaal geprojecteerd bedrag van US$37.040,0 m tegen 2028’.</p>
<p>Tegelijkertijd zou de DeFi-markt in 2024 een gemiddelde omzet per gebruiker van US$1.378,0 kunnen behalen. Een groot deel van deze omzet zal afkomstig zijn van gedecentraliseerde beurzen (DEX’s) die gebruikers in staat stellen om crypto-activa te verhandelen zonder tussenpersonen of centrale autoriteit. Op dezelfde manier kan het aantal DeFi-gebruikers tegen 2028 toenemen tot 22,09 m.</p>
<h2 id="h2-SEC20herdefinieert20deermen20handhaaft20uitgebreide20registratie20in20de20Verenigde20Staten126638"><a name="SEC herdefinieert deermen, handhaaft uitgebreide registratie in de Verenigde Staten" class="reference-link"></a><span class="header-link octicon octicon-link"></span>SEC herdefinieert deermen, handhaaft uitgebreide registratie in de Verenigde Staten</h2><p>De SEC streeft ernaar een manier te vinden om de DeFi-sector onder toezicht van de regelgeving te brengen door de definities van “handelaar” en “overheids-effectenhandelaar” uit te breiden. De nieuwe definitie van handelaar zal van toepassing zijn op de cryptocurrency-sector.</p>
<p>De regels die de SEC op 6 februari heeft aangenomen, zullen vereisen dat marktdeelnemers zich bij haar registreren en voldoen aan federale effectenwetten en marktregelgeving. Bovendien zal de SEC van elke marktdeelnemer vereisen dat hij lid wordt van een zelfregulerende organisatie.</p>
<p>In feite vervullen de handelaren belangrijke marktfuncties, zoals het bieden van liquiditeit aan kopers en verkopers en het absorberen van orderonevenwichtigheden. Volgens een recente <a href="https://www.sec.gov/news/statement/crenshaw-statement-dealer-trader-020624" rel="nofollow noopener noreferrer" target="_blank">overheidsverklaring een dealer is gedefinieerd</a> als ‘elke persoon die zich bezighoudt met het kopen of verkopen van effecten voor eigen rekening’.</p>
<p>Het verduidelijkt verder dat, “handelaren de dienst van onmiddellijke handel bieden… de verstrekking van liquiditeit, inclusief optreden als een “markt maker” of “een de facto marktmaker”.</p>
<p><a href="https://www.sec.gov/news/statement/crenshaw-statement-dealer-trader-020624#_ftn9" rel="nofollow noopener noreferrer" target="_blank">Commissaris Caroline Crenshaw legde uit</a> het belang van de nieuwe regels. Ze zei: “Er is hier duidelijk een maas in de wet: marktpartijen met een aanzienlijk marktaandeel zijn bezig met activiteiten zoals die van dealers, zonder geregistreerd te zijn als dealers.”</p>
<p>‘De regels die we vandaag overwegen zouden helpen om deze regelgevingskloof te dichten en het speelveld gelijk te maken door marktpartijen die vergelijkbare dealerfuncties uitvoeren onderworpen te stellen aan een gemeenschappelijk regelgevingsregime,’ voegde ze eraan toe.</p>
<p>Dergelijke sentimenten van een toezichthouder tonen aan dat de uitgebreide definities van “dealer” en “overheidseffectenhandelaar” waarschijnlijk binnenkort van toepassing zullen zijn op de cryptomarkt en daarmee DeFi-trends in 2024 opnieuw definiëren.</p>
<h2 id="h2-Conclusie829340"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Monica Long, die de president van Ripple is, zei onlangs dat de DeFi-sector zich moet houden aan marktreguleringen om groter succes te behalen dan voorheen. Ze benadrukte dat Ripple veel zal doen om zich te houden aan bestaande en opkomende wetten. In een gerelateerde stap heeft de Verenigde Staten als doel om de definities van ‘handelaar’ en ‘effectenhandelaar van de overheid’ te veranderen, zodat ze van toepassing zijn op de cryptosector.</p>
<h2 id="h2-Veelgestelde20vragen20over20DeFi469620"><a name="Veelgestelde vragen over DeFi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over DeFi</h2><h3 id="h3-Zijn20DeFi20munten20een20goede20investering472932"><a name="Zijn DeFi munten een goede investering?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Zijn DeFi munten een goede investering?</h3><p>Sommige DeFi-munten hebben het potentieel om betere rendementen op investeringen te bieden dan traditionele financiële activa. Toonaangevende cryptocurrencies zoals <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> en Ether kunnen goede rendementen opleveren via programma’s zoals liquiditeitsvoorziening en staking.</p>
<h3 id="h3-Hoe20groot20is20DeFi20vandaag146137"><a name="Hoe groot is DeFi vandaag?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe groot is DeFi vandaag?</h3><p>De totale marktkapitalisatie van DeFi is meer dan $79,5 miljard en heeft het potentieel om verder te stijgen. De marktkapitalisatie van DeFi op een bepaald moment is echter afhankelijk van de prestaties van de verschillende tokens en munten.</p>
<h3 id="h3-Wat20wordt20beschouwd20als20DeFi666353"><a name="Wat wordt beschouwd als DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat wordt beschouwd als DeFi?</h3><p>DeFi, wat staat voor gedecentraliseerde financiën, is een financiële technologie gebaseerd op de blockchain en maakt gebruik van cryptocurrency voor peer-to-peer betalingen. Het heeft als doel om hoge transactiekosten en betalingsvertragingen die bestaan in de traditionele financiële sector te verminderen.</p>
<h2 id="h2-Waar20staat20DeFi20voor271100"><a name="Waar staat DeFi voor?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Waar staat DeFi voor?</h2><p>DeFi staat voor gedecentraliseerde financiën waar mensen en instellingen cryptocurrencies gebruiken om betalingen te doen via een peer-to-peer systeem. Momenteel zijn er duizenden virtuele valuta voor dat doel.</p>
<h2 id="h2-Is20DeFi20illegaal20in20de20Verenigde20Staten50963"><a name="Is DeFi illegaal in de Verenigde Staten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is DeFi illegaal in de Verenigde Staten?</h2><p>DeFi is legaal in de Verenigde Staten, hoewel er behoefte is aan cryptobedrijven zoals beurzen om te voldoen aan marktregelgeving in het land. In de VS kunnen mensen cryptocurrencies verwerven, aanhouden en verhandelen. Ze kunnen ze ook gebruiken voor betalingen, hoewel ze geen wettig betaalmiddel zijn.</p>
<h3 id="h3-Wat20is20de20DeFitrend20in202024620216"><a name="Wat is de DeFi-trend in 2024?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de DeFi-trend in 2024?</h3><p>In 2024 zijn de meeste DeFi-projecten van plan om te voldoen aan verschillende regelgevingen die in verschillende landen bestaan. Bedrijven in de sector streven er ook naar om samen te werken met bedrijven die actief zijn in de traditionele financiële sector om de adoptie van crypto-activa te vergroten.</p>
<h3 id="h3-Hoe20groot20is20de20DeFimarkt514764"><a name="Hoe groot is de DeFi-markt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Hoe groot is de DeFi-markt?</h3><p>De DeFi-markt heeft een totale marktkapitalisatie van meer dan $79,5 miljard, met het vooruitzicht van verdere groei in 2024. We verwachten ook dat er nieuwe DeFi-projecten op de markt zullen komen in 2024 en daarna.</p>
<h3 id="h3-Is20er20een20toekomst20in20DeFi307111"><a name="Is er een toekomst in DeFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Is er een toekomst in DeFi?</h3><p>DeFi is de toekomst van de wereldwijde financiële sector als veel mensen en organisaties cryptocurrencies gaan gebruiken. Dit komt doordat het transparante, kosteneffectieve en veilige betalingen mogelijk maakt.</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 standpunten van de onderzoeker en vormt geen 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 vanwege schending van het auteursrecht.<br></div><p></p><br></div></div></div>