WmlqbiBkZSB0b2tlbnMgdmFuIGhldCBvdWRlIG1lcmsgTDEgUHVibGljIENoYWluIGdlw6t4cGxvZGVlcmQsIHppam4gZXIga2Fuc2VuIG9wIGdyb2VpPw==

2023-11-20, 03:03

<p><img src="https://gimg2.gateimg.com/image/article/1692587449analysis.jpeg" alt=""></p>
<h2 id="h2-TLDR311931"><a name="[TL;DR]:" class="reference-link"></a><span class="header-link octicon octicon-link"></span>[TL;DR]:</h2><p>Onlangs hebben een reeks L1-tokens een aanzienlijke stijging gezien en de lente ingeluid, waarbij de regel ‘het nieuwe bakken in plaats van het oude’ werd doorbroken.</p>
<p>De logica achter de opkomst van ervaren L1-spelers is niet zo eenvoudig als de overloop van <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> Fondsen. Ook de eigen technologie en de opbouw van ecoen spelen een belangrijke rol.</p>
<p>Geconfronteerd met de opkomst van Rollup en de nieuwe publieke keten, heeft het oude merk L1 een nieuw verhaal nodig om marktaandeel te veroveren.</p>
<h2 id="h2-Introductie477994"><a name="Introductie" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introductie</h2><p>Sinds het begin van het vierde kwartaal heeft de aanzienlijke stijging van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> geleid tot een sterke stijging van de cryptomarkt in het algemeen. Deze golf van hot money die Bitcoin omhoog duwt, lijkt de ijzeren regel van ‘het nieuwe in plaats van het oude bakken’ in het verleden te hebben verlaten, en veel L1-oude merk public chain tokens zijn sterk hersteld.</p>
<p>Als een essentiële publieke ketensector in elke stierenmarkt, hebben veteraan publieke ketentokens ook de lente verwelkomd.</p>
<h2 id="h2-De20Lente20van20Legacy20L120Public20Chain20Tokens205838"><a name="De Lente van Legacy L1 Public Chain Tokens" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De Lente van Legacy L1 Public Chain Tokens</h2><p><a href="/price/ethereum-eth" rel="nofollow noopener noreferrer" target="_blank">Ethereum</a> is geleidelijk naar de achtergrond verdwenen en is begonnen met een ‘huurincasso’-bedrijf. Hoewel in de ogen van de meeste mensen L2 het belangrijkste verhaal zal zijn van de nieuwe bullmarkt, betekent dit niet dat de oude L1 openbare ketens zich zullen terugtrekken van het historische toneel. De recente aanzienlijke stijging van een reeks L1-tokens lijkt erop te wijzen dat ook zij de lente zullen verwelkomen.<img src="https://gimg2.gateimg.com/image/article/170044919315121700448754_.pic.jpg" alt=""><br>Bron: CoinGecko</p>
<p>Sinds het begin van dit jaar is de meest opvallende toename geweest in <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>, het eerste niveau van de publieke keten in de vorige bullmarkt.</p>
<p>Dankzij zijn strategie van ‘het waarderen van het ecosysteem meer dan de technologie’, heeft <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> gekozen voor een meer gecentraliseerde technologische oplossing, waarbij het vertrouwt op een groot aantal stimulerende maatregelen om talloze ontwikkelaars en gebruikers aan te trekken. Dit jaar is Solana opgekomen uit het moeras van FTX met een verbluffende prestatie van bijna een 5-voudige stijging, en de valutaprijs heeft zijn hoogste record bereikt in 14 maanden.</p>
<p>En andere ‘Ethereum moordenaars’ zijn ook niet bereid om achter te blijven. Na een periode van zes maanden van bodemvorming en stilte, zijn ze onlangs begonnen aan een sterke opwaartse trend.</p>
<p>ADA, de gevestigde publieke ketenreus van Japan, heeft sinds oktober een groeipercentage van meer dan 60% gezien, terwijl <a href="/price/qtum-qtum" target="_blank" class="blog_inner_link">QTUM</a> en ONT met een gemiddelde ecosysteemontwikkeling ook meer dan 60% groeirendement hebben ontvangen. In de vorige bullmarkt hebben de beroemde <a href="/price/flow-flow" target="_blank" class="blog_inner_link">FLOW</a> en FTM een groeipercentage van meer dan 80% geregistreerd in de afgelopen maand.</p>
<p>De meest opvallende zijn MATIC, NEAR en AVAX, die in de afgelopen anderhalve maand met 100% zijn gestegen, op één na alleen SOL.<br>Daarnaast is de langdurige openbare keten <a href="/price/neo-neo" rel="nofollow noopener noreferrer" target="_blank">NEO</a>, die lange tijd inactief was, ontving ook meer dan 100% rendement vanwege de Koreaanse hype.</p>
<h2 id="h2-Overvalherstel20of20waardeherstel27425"><a name="Overvalherstel of waardeherstel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Overvalherstel of waardeherstel?</h2><p>Als het oudste openbare ketenproject heeft <a href="/price/ethereum-eth" target="_blank" class="blog_inner_link">Ethereum</a> de meeste ecosysteemtoepassingen in de huidige cryptowereld. Volgens gegevens van DefiLlama bereikt de huidige TVL op de Ethereum-keten $ 25,258 miljard, goed voor 54,84% van alle openbare links.</p>
<p>Maar een intrigerende trend is dat het marktaandeel van Ethereum geleidelijk afneemt. Zoals hieronder weergegeven, naast enkele L2 die de druk op het Ethereum-marktaandeel vullen, ondergaan ook veel L1 openbare ketenprojecten een ‘oude bomen bloeien nieuwe bloemen.’ Is de opkomst van deze openbare ketentokens te wijten aan het overloopeffect van Bitcoin-fondsen, of krijgen ze werkelijk marktherkenning vanwege hun potentieel?<img src="https://gimg2.gateimg.com/image/article/170044925115131700448771_.pic.jpg" alt=""><br>Bron: DefiLlama</p>
<p>Als de L1 openbare keten van het POS-mechanisme dat in 2017 is gelanceerd, <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a> (ADA) heeft altijd bekend gestaan om zijn unieke technische concept, met zijn consensusalgoritme Ouroboros en programmeertaal Hashkell die aanzienlijk superieur is aan de meeste projecten op hetzelfde spoor. Sinds het ingaan van 2023 hebben Cardano-ontwikkelaars, ondanks de tijdelijke daling van de muntprijzen, multi-chain-oplossingen verbeterd, zoals Hydra Head en Milkomeda C1 zijketens.</p>
<p>Op de schrijfdatum heeft <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> momenteel 146 toepassingen en projecten die op zijn netwerk draaien, en het aantal projecten in aanbouw is gestegen naar 1280.</p>
<p>Een andere achtergrond die moet worden uitgelegd, is dat een van de grootste technische problemen waarmee openbare ketens worden geconfronteerd, capaciteitsuitbreiding is. Monomeerketens proberen de prestaties te verbeteren door blokgroottes aan te passen, maar kunnen nog steeds nadelen zoals on-chain congestie, hoge gasvergoedingen en overmatige centralisatie niet vermijden. De modularisatie van de consensuslaag wordt vertegenwoordigd door Cosmos’ Tendermint en <a href="/price/polkadot-dot" rel="nofollow noopener noreferrer" target="_blank">Polkadot</a> Substraat van . De technologische ontwikkeling van deze modulaire netwerken zal effectief compenseren voor de tekortkomingen van Rollup en meer ruimte bieden voor ecoische composability.</p>
<p>Natuurlijk zal Cosmos zich voornamelijk richten op de technologische upgrade van IBC in 2022, maar er is nog geen wezenlijke vooruitgang geboekt op het gebied van interchain-accounts en beveiligingsmaatregelen, evenals de waarde-opvangcapaciteit van. <a href="/price/cosmos-hub-atom" rel="nofollow noopener noreferrer" target="_blank">Cosmos Hub</a>. Dit zal ook een belangrijke taak worden voor het activeren van de waarde van zijn tokens in 2023-2024.</p>
<p>Multi-chain netwerken gebouwd op hetzelfde ontwikkelingsraamwerk en modulaire tools zijn nog steeds gaande, zoals <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a> Keten, <a href="/price/avalanche-avax" rel="nofollow noopener noreferrer" target="_blank">Avalanche</a>, en anderen die actief EVM’s L2-oplossing implementeren in de bearmarkt.</p>
<p>Het roadmap voor de sharding publieke ketting Near, die zich richt op draadloze schaalbaarheid, is voornamelijk om het tweede sharding protocol Phase2 in 2023 uit te brengen en de derde sharding Phase3 in 2024 te leveren. Momenteel is er nog steeds een afstand van zijn voorgestelde doel om over te stappen van layer1 blockchain naar een blockchain besturingssysteem.</p>
<p>De oude <a href="/price/fantom-ftm" rel="nofollow noopener noreferrer" target="_blank">Fantom</a> Het ecosysteem steunt voornamelijk op de persoonlijke charme van AC en de omleiding van kant-en-klare producten. Na de terugkeer van AC werd het Dapp Gas-monetisatieplan gelanceerd om het FTM-vernietigingspercentage te verminderen en er werd aanzienlijke vooruitgang geboekt op het gebied van virtuele machines (FVM’s).</p>
<p>Avalanche, dat zich richt op samenwerking binnen bedrijven, bouwt ook voortdurend in de berenmarkt. Het officiële team heeft dit jaar het high-performance virtual machine netwerk HyperSDK gelanceerd, de lancering van AvaCloud voor ontwikkelaars om codeless blockchain te implementeren en uit te breiden, en heeft samengewerkt met meerdere Web2 en <a href="/web3" target="_blank" class="blog_inner_link">Web3</a> instellingen, met de focus op het metaverse en gamingvelden.</p>
<p>Ethereum sidechain <a href="/price/polygon-matic" rel="nofollow noopener noreferrer" target="_blank">Polygon</a> is druk bezig met het bevorderen van het Polygon2.0-plan. <a href="/price/polygon-matic" target="_blank" class="blog_inner_link">Polygon</a> 2.0 is eigenlijk een upgrade-plan dat in juni van dit jaar door Polygon is aangekondigd en bestaat uit vier aspecten: Polygon PoS-upgrade, technische architectuur-upgrade, update van de token-economie en upgrade van het bestuursmechanisme. Het heeft als doel om een ​​geünificeerd netwerk te worden dat bestaat uit L2-ketens die worden ondersteund door ZK-technologie. Dankzij zijn rijke technische en praktische reserves heeft Polygon zkEVM zijn adoptie versneld en staat het momenteel op de zevende plaats in de ZK-oplossing.</p>
<p>Hoewel de opkomst van de oude merk openbare keten <a href="/price/neo-neo" target="_blank" class="blog_inner_link">NEO</a> (GAS) is gehyped door Zuid-Korea, zijn de fundamenten zelf niet zonder verdienste. Sinds het NEO-team is overgestapt van een enkel bestuursmechanisme naar een sterk stimuleringsmodel, zijn de productie en distributie van GAS-tokens redelijker geworden; Volgens oprichter Da Hongfei creëert NEO ook een zijketen die bestand is tegen Miner Extractable Value (MEV)-aanvallen en compatibel is met Ethereum Virtual Machines (EVM’s). De NEO-zijketen zal eind 2023 worden uitgebracht.</p>
<p>GateChain is een openbare keten van de nieuwe generatie, gefinancierd door Gate.io die zich richt op de beveiliging van gebruikersactiva en gedecentraliseerde transacties. De innovatieve online hot-verzekeringsrekening en het ondersteunende ontwerp van het transactiemodel bieden veilige clearingbescherming. Deze keten is dit jaar doorgegaan met het implementeren van het mainnet Gas-model, waardoor de waarde van token GT onder het GT-vergoedingsverbrandingsmechanisme aanzienlijk is toegenomen.</p>
<p>Solana daarentegen is begonnen terug te keren naar het perspectief van het publiek door technologische upgrades te versnellen en hackactiviteiten te organiseren. We hebben hier al een apart artikel over geschreven op ons blog om het te bespreken, en we zullen hier niet verder op ingaan.</p>
<h2 id="h2-Oude20merk20openbare20ketens20zijn20aan20het20herstellen20maar20duurzame20ontwikkeling20kost20nog20steeds20tijd183944"><a name="Oude merk openbare ketens zijn aan het herstellen, maar duurzame ontwikkeling kost nog steeds tijd" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Oude merk openbare ketens zijn aan het herstellen, maar duurzame ontwikkeling kost nog steeds tijd</h2><p>Feitelijk is het bij terugkijken naar het verleden niet moeilijk om te vinden dat de reden waarom de concurrentie op het gebied van publieke blockchains steeds feller wordt, is dat het dient als de infrastructuur en onderliggende vraag voor de cryptobranche.</p>
<p>Van 2020 tot 2021 hebben verschillende ecoen zoals DeFi, NFT, DAO, Sociaal en andere sectoren schommelingen ervaren, en de marktketenoperaties waren buitengewoon actief. Als gevolg van de enorme vraag naar Ethereum blockspace stroomden veel investeerders en gebruikers naar het nieuwe L1 (Alt L1) met een hogere capaciteit en lagere kosten, wat destijds enorme waardeverhoging bracht voor de L1 openbare keten.</p>
<p>Maar naarmate de markt verandert in een bear market, zullen veel gevestigde publieke ketens ook hun vele nadelen onthullen. Bij het betreden van de bear market van 2022 werd <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> Chain diep in twijfel getrokken over centralisatie, werd het stablecoin-plan van NEAR geannuleerd en werd <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> blootgesteld aan een schandaal van hevige concurrentie. <a href="/price/harmony-one" rel="nofollow noopener noreferrer" target="_blank">Harmonie</a> bijna ingestort door het hackincident, en <a href="/price/fantom-ftm" target="_blank" class="blog_inner_link">Fantom</a> viel van het altaar door het vertrek van zijn oprichter en een ontoereikend ecosysteem.</p>
<p>Nieuwe dingen ontwikkelen en verbeteren zich altijd met horten en stoten. Geconfronteerd met de voortdurend naderende Ethereum Rollup ‘nieuwe krachten’, is het duidelijk niet langer houdbaar om vast te houden aan het verhaal van de oude L1-spelers met hoge prestaties en lage kosten. Ook de nieuwe L1 openbare keten betreedt geleidelijk de markt, en de bestaande ecosysteemprojecten zijn sterk gehomogeniseerd en overvol, waarbij nieuwe verhalen nodig zijn om marktaandeel te veroveren.</p>
<p>Naar mijn mening moet de oude merk openbare keten naast de focus op compatibiliteit met de tweede laag van Ethereum in technologie, ook op een alomvattende manier ecosysteembronnen en marketingcapaciteiten integreren. Het kan gezegd worden dat toekomstige concurrentie zal verschuiven van eenvoudige technologische optima naar unieke en gedifferentieerde ecosysteemkringen.</p>
<p>In feite is dit fenomeen al tijdens de vorige stierenmarkt begonnen en heeft de krachtige ontwikkeling van veel nieuwe gebieden geleid tot de opbouw van concurrentiebarrières voor verticale openbare ketens die zich richten op gesegmenteerde gebieden op de markt. Zo lanceerde Solana bijvoorbeeld in het tweede kwartaal van dit jaar een revolutionaire oplossing voor staatcompressie, waarmee de kosten voor NFT-opslag met 2400-24000 keer kunnen worden verlaagd. Polymeresh, dat gespecialiseerd is in het bedienen van conforme activa RWA-tracks, heeft bijvoorbeeld een positie verworven in hun respectievelijke gebieden.</p>
<p><img src="https://gimg2.gateimg.com/image/article/170044935015141700448797_.pic.jpg" alt=""><br>Bron: POLYMESH</p>
<p>Samengevat is de logica achter de opkomst van ervaren L1-spelers niet zo eenvoudig als de overvloed aan Bitcoin-fondsen. Ook hun eigen technologie en ecosysteemconstructie spelen een belangrijke rol.</p>
<p>Inderdaad heeft elke openbare keten zijn eigen verschillende overwegingen en keuzes in de nieuwe competitieve dimensie, en de enigszins FOMO-markt heeft ook nieuwe waarderingen gegeven, maar er is niet veel tijd over voor iedereen.</p>
<p>De korte termijn stijging is niet het einde, en duidelijke richting planning, evolutie en upgrading van technische oplossingen, evenals de bouw van ecosysteemtoepassingen, zullen steeds meer de algehele capaciteiten van ervaren L1 publieke ketens testen.</p>
<div class="blog-details-info"><br><div>Auteur:<strong>Carl Y.</strong>, Gate.io-onderzoeker<br><div>Vertaler: Joy Z.<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de standpunten 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 is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div></div>