SXMgZXIgbm9nIGlldHMgYW5kZXJzIGluIGhldCBCYXNlLWVjb3N5c3RlZW0gZGF0IGVlbiBrcmFjaHQga2FuIHppam4gbmEgRnJpZW5kLnRlY2g/

2023-09-08, 03:05

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-120Basis20Ecosysteem20Overzicht182073"><a name="1 Basis Ecosysteem Overzicht" class="reference-link"></a><span class="header-link octicon octicon-link"></span>1 Basis Ecosysteem Overzicht</h2><p>Als een L2-project dat binnen twee maanden na de lancering van het hoofdnet is gestart, heeft Base een verkeershalo en opvallende ecosysteemgegevens.</p>
<p>Volgens de officiële website zijn er 144 Base-ecosysteemprojecten/partners, waarbij infrastructuurprojecten meer dan de helft uitmaken, waaronder cross-chain bruggen, wallets, oracle machines, On-Ramp, node serviceproviders, enzovoort. Ondertussen, <a href="/price/uniswap-uni" rel="nofollow noopener noreferrer" target="_blank">Uniswap</a>, MakerDAO, <a href="/price/aave-aave" rel="nofollow noopener noreferrer" target="_blank">Aave</a>, <a href="/price/compound-comp" rel="nofollow noopener noreferrer" target="_blank">Compound</a>, en andere multi-chain DeFi-protocollen zijn ook geïntegreerd om de Base chain te ondersteunen. Tegelijkertijd hebben inheemse DeFi-projecten een groot aantal, maar een klein marktaandeel laten zien.</p>
<p>Volgens L2BEAT-gegevens heeft de Base Chain TVL op 5 september $ 378 miljoen bereikt, op de vierde plaats in Layer2 met een omzet van $ 4,02 miljoen in slechts 30 dagen. Er zijn 6.535.000 dagelijkse actieve adressen en 301.500 dagelijkse transactievolumes. De piek van deze gegevens is aanzienlijk afgenomen sinds de voorkoeling van friend.tech op 22 augustus. Momenteel zijn deze gegevens lager dan de top Layer-2-netwerken zoals Arbitrum, <a href="/price/optimism-op" rel="nofollow noopener noreferrer" target="_blank">Optimisme</a>, en zkSync.<br><img src="https://gimg2.gateimg.com/image/article/16941421348651694142032_.pic.jpg" alt=""><br>Bron: L2BEAT</p>
<h2 id="h2-220DEX179246"><a name="2 DEX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>2 DEX</h2><p>Volgens de gegevens verzameld door DefiLlama, is het totale aantal DEX-projecten op de Base-keten 22, wat een kwart is van het totale aantal protocollen.</p>
<p>Een kwart van het totale aantal overeenkomsten. Volgens de TVL-gegevens van DefiLlama is de beste inheemse DEX Aerochrome, die onlangs is begonnen met liquiditeits mining en een hoge APY biedt, met een TVL van $ 178 miljoen op de publicatiedatum. Aerodrome is een Base liquiditeitslaag die gezamenlijk is ontwikkeld door Velodrome, het Base-team en partners. De initiele voorraad is 500M AERO, waarvan 450M (90%) wordt vergrendeld als veAERO.</p>
<p>DEX is een racebaan met een rood zee voor crypto-protocollen, met felle concurrentie. De eerder grotere Leetswap en Rocketswap op de Base-keten werden allemaal gesloten vanwege beveiligingsincidenten, terwijl andere native DEX-lock-ups zoals BaseSwap, AlienBase en DackieSwap lage lockdowns hebben en nog geen levensvatbare opties zijn geworden.<br><img src="https://gimg2.gateimg.com/image/article/16941421648661694142046_.pic.jpg" alt=""><br>Bron: DefiLama</p>
<h2 id="h2-320Leningen797078"><a name="3 Leningen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>3 Leningen</h2><p>Het uitleenprotocol <a href="/price/compound-comp" target="_blank" class="blog_inner_link">Compound</a> werd gelanceerd op de Base medio augustus en ondersteunt onderpand ETH en cbETH om cross-chain USDC’s (USDbC op de Base) te lenen, met een huidige TVL van $299,6 miljoen. <a href="/price/aave-aave" target="_blank" class="blog_inner_link">Aave</a> V3 heeft ook gestemd en Base gelanceerd op 20 augustus.</p>
<p>Andere uitleenprotocollen die zijn gelanceerd of zullen worden gelanceerd als Base, waaronder Moonwell op <a href="/price/moonbeam-glmr" rel="nofollow noopener noreferrer" target="_blank">Moonbeam</a>, Extra on Leveraged Return Strategy en uitleenprotocol, en PickFinance op Cross Chain uitleenprotocol, bevinden zich allemaal in hun beginfase.</p>
<p>Ook de uitleensector op Base heeft een vloerkleedincident meegemaakt, waar de contractontwikkelaar van het oorspronkelijke grootste inheemse uitleenprotocol, Magnate Finance, geassocieerd is met de Solfire-zwendel. Momenteel is zijn Twitter-account geannuleerd.<br><img src="https://gimg2.gateimg.com/image/article/16941421928671694142060_.pic.jpg" alt=""><br>Bron: DefiLama</p>
<h2 id="h2-420Derivaat774991"><a name="4 Derivaat" class="reference-link"></a><span class="header-link octicon octicon-link"></span>4 Derivaat</h2><p>KRAV is een gedecentraliseerd en duurzaam handelsplatform met dubbele valuta op de Basis-keten dat ondersteuning biedt voor hefboomhandel met Altcoins als onderpand. Het introduceert een universeel tariefmechanisme voor fondsbeheer en heeft een automatisch sterk balanceringsproces waarbij de positiewaarde meer dan 90% van het onderpand bedraagt. Na de lancering van het protocol bereikte de TVL een maximum van 1,44 miljoen dollar, en is nu terugglen tot 900.000 dollar.</p>
<p>Daarnaast zijn er meer actieve platforms zoals EDABSE, een duurzaam en spot-handelsplatform vergelijkbaar met <a href="/price/gmx-gmx" rel="nofollow noopener noreferrer" target="_blank">GMX</a>, en Meridian Trade, dat renteloze stablecoin-uitlening en gehefboomde handel biedt. Over het algemeen ontbreekt het echter aan innovatie bij DEX, en als transactiekosten en gebruikerservaring niet fundamenteel kunnen worden opgelost, zal het op korte termijn nog steeds niet in staat zijn om door te breken in de ontwikkelingsblokkades.<br><img src="https://gimg2.gateimg.com/image/article/16941422228681694142075_.pic.jpg" alt=""><br>Bron: DefiLama</p>
<h2 id="h2-520Sociaal176846"><a name="5 Sociaal" class="reference-link"></a><span class="header-link octicon octicon-link"></span>5 Sociaal</h2><p>Friend.tech is het eerste fan-economie product op de Base-keten dat populair is geworden, en de basislogica ervan is om persoonlijke IP te tokeniseren of NFT te maken, waardoor gebruikers vrij kunnen kopen en verkopen. Friend.tech zorgde voor een opleving en een grote instroom van geld in medio augustus, maar sinds 22 augustus is er een voortdurende nettostroom van geld uit Friend.tech, wat heeft geleid tot een aanzienlijke afname van de handelsenthousiasme.<br><img src="https://gimg2.gateimg.com/image/article/16941422438691694142086_.pic.jpg" alt=""><br>Bron: DefiLama</p>
<h2 id="h2-620Crosschain20Brug643621"><a name="6 Cross-chain Brug" class="reference-link"></a><span class="header-link octicon octicon-link"></span>6 Cross-chain Brug</h2><p>Naast de officiële brug van Base (die alleen cross-chain ETH ondersteunt tussen <a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> en Base), het Base-ecosysteem cross-chain bridge omvat ook Orbiter Finance, Bunge, Hop Protocol, LayerZero, Stargate, debridge, cross-Rollup Bridge OwltoFinance en meer.</p>
<p>Er zijn slechts een paar cross-chain brugproducten zoals Stargate, Synapse en Hop Protocol met meer dan een miljoen dollar in TVL.<br><img src="https://gimg2.gateimg.com/image/article/16941422688701694142103_.pic.jpg" alt=""><br>Bron: chaineye.tools</p>
<h2 id="h2-720DAO728743"><a name="7 DAO" class="reference-link"></a><span class="header-link octicon octicon-link"></span>7 DAO</h2><p>Op dit moment hebben toonaangevende DAO-oplossingsproviders Aragon, XDAO en NounsDAO infrastructuur voor gemeenschapsfinanciering PropHouse, DAO-exploratie en ondersteuningsprotocol Tally gebouwd om Base te ondersteunen.</p>
<h2 id="h2-Conclusie538312"><a name="Conclusie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusie</h2><p>Over het algemeen zijn er meerdere tapijtinstanties geweest in de inheemse projecten op de Base-keten, en de ecologische lay-out bevindt zich nog in de beginfase. Hoewel sommige aardhonden- en sociale projecten op korte termijn de aandacht van de Base-keten hebben getrokken, is het feest slechts tijdelijk in de huidige marktcontext van gebrek aan liquiditeit. Met het herstel van de markt en de neerslag van het Base-ecosysteem zullen projecten met duurzame waarde een ware explosieve periode tegemoet gaan.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Peter L.</strong>, Gate.io onderzoeker<br><div>Vertaler: Joy Z.<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 plaatsen van het artikel zal worden toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div></div>